Built with Alectryon, running Coq+SerAPI v8.15.0+0.15.0. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus. On Mac, use ⌘ instead of Ctrl.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "_ + _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ - _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ < _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ >= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ > _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ <= _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ * _" was already used in scope nat_scope.
[notation-overridden,parsing]


Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]


Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]


Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]


(** Throughout this file, we assume ideal uni-processor schedules. *)

Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]


Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]



(** * JLFP instantiation of Interference and Interfering Workload for ideal uni-processor. *)
(** In this module we instantiate functions Interference and Interfering Workload
    for an arbitrary JLFP-policy that satisfies the sequential tasks hypothesis.
    We also prove equivalence of Interference and Interfering Workload to the
    more conventional notions of service or workload. *)
Section JLFPInstantiation.

  (** Consider any type of tasks ... *)
  Context {Task : TaskType}.
  Context `{TaskCost Task}.

  (**  ... and any type of jobs associated with these tasks. *)
  Context {Job : JobType}.
  Context `{JobTask Job Task}.
  Context `{JobArrival Job}.
  Context `{JobCost Job}.

  (** Consider any valid arrival sequence with consistent arrivals... *)
  Variable arr_seq : arrival_sequence Job.
  Hypothesis H_valid_arrival_sequence : valid_arrival_sequence arr_seq.

  (** ... and any ideal uni-processor schedule of this arrival sequence... *)
  Variable sched : schedule (ideal.processor_state Job).
  Hypothesis H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched arr_seq.

  (** ... where jobs do not execute before their arrival nor after completion. *)
  Hypothesis H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched.
  Hypothesis H_completed_jobs_dont_execute : completed_jobs_dont_execute sched.

  (** Assume we have sequential tasks, i.e., jobs of the
     same task execute in the order of their arrival. *)
  Hypothesis H_sequential_tasks : sequential_tasks arr_seq sched.

  (** Consider a JLFP-policy that indicates a higher-or-equal priority relation,
     and assume that this relation is reflexive and transitive. *)
  Context `{JLFP_policy Job}.
  Hypothesis H_priority_is_reflexive : reflexive_priorities.
  Hypothesis H_priority_is_transitive : transitive_priorities.

  (** We also assume that the policy respects sequential tasks, meaning
     that later-arrived jobs of a task don't have higher priority than
     earlier-arrived jobs of the same task. *)
  Hypothesis H_JLFP_respects_sequential_tasks : policy_respects_sequential_tasks.

  (** Let [tsk] be any task to be analyzed. *)
  Variable tsk : Task.

  (** For simplicity, let's define some local names. *)
  Let job_scheduled_at := scheduled_at sched.
  Let job_completed_by := completed_by sched.
  Let cumulative_task_interference := cumul_task_interference arr_seq sched.

  (** ** Interference and Interfering Workload *)
  (** In this section, we introduce definitions of interference,
      interfering workload, and a function that bounds cumulative interference. *)

  (** In order to introduce the interference, first we need to recall
      the definition of priority inversion. We say that job [j] is
      incurring a priority inversion at time [t] if there exists a job
      with lower priority that executes at time [t]. In order to
      simplify things, we ignore the fact that according to this
      definition a job can incur priority inversion even before its
      release (or after completion). All such (potentially bad) cases
      do not cause problems, as each job is analyzed only within the
      corresponding busy interval where the priority inversion behaves
      in the expected way. *)
  Let is_priority_inversion (j : Job) (t : instant) :=
    priority_inversion_dec arr_seq sched j t.

  (** Next, we say that job [j] is incurring interference from another
      job with higher or equal priority at time [t], if there exists a
      job [jhp] (different from [j]) with higher or equal priority
      that executes at time [t]. *)
  Definition is_interference_from_another_hep_job (j : Job) (t : instant) :=
    if sched t is Some jhp then
      another_hep_job jhp j
    else false.

  (** Similarly, we say that job [j] is incurring interference from a
      job with higher or equal priority of another task at time [t],
      if there exists a job [jhp] (of a different task) with higher or
      equal priority that executes at time [t]. *)
  Definition is_interference_from_hep_job_from_another_task (j : Job) (t : instant) :=
    if sched t is Some jhp then
      another_task_hep_job jhp j
    else false.

  (** Now, we define the notion of cumulative interference, called
      [interfering_workload_of_hep_jobs], that says how many units of
      workload are generated by jobs with higher or equal priority
      released at time [t]. *)
  Definition interfering_workload_of_hep_jobs (j : Job) (t : instant) :=
    \sum_(jhp <- arrivals_at arr_seq t | another_hep_job jhp j) job_cost jhp.

  (** Instantiation of Interference *)
  (** We say that job [j] incurs interference at time [t] iff it
      cannot execute due to a higher-or-equal-priority job being
     scheduled, or if it incurs a priority inversion. *)
  Definition interference (j : Job) (t : instant)  :=
    is_priority_inversion j t || is_interference_from_another_hep_job j t.

  (** Instantiation of Interfering Workload *)
  (** The interfering workload, in turn, is defined as the sum of the
      priority inversion function and interfering workload of jobs
      with higher or equal priority. *)
  Definition interfering_workload (j : Job) (t : instant) :=
    is_priority_inversion j t + interfering_workload_of_hep_jobs j t.

  (** For each of the concepts defined above, we introduce a corresponding cumulative function: *)
  (** (a) cumulative priority inversion... *)
  Definition cumulative_priority_inversion (j : Job) (t1 t2 : instant)  :=
    \sum_(t1 <= t < t2) is_priority_inversion j t.

  (** ... (b) cumulative interference from other jobs with higher or equal priority... *)
  Let cumulative_interference_from_other_hep_jobs (j : Job) (t1 t2 : instant) :=
    \sum_(t1 <= t < t2) is_interference_from_another_hep_job j t.

  (** ... (c) and cumulative interference from jobs with higher or equal priority from other tasks... *)
  Definition cumulative_interference_from_hep_jobs_from_other_tasks (j : Job) (t1 t2 : instant) :=
    \sum_(t1 <= t < t2) is_interference_from_hep_job_from_another_task j t.

  (** ... (d) cumulative interference... *)
  Let cumulative_interference (j : Job) (t1 t2 : instant) := \sum_(t1 <= t < t2) interference j t.

  (** ... (e) cumulative workload from jobs with higher or equal priority... *)
  Let cumulative_interfering_workload_of_hep_jobs (j : Job) (t1 t2 : instant) :=
    \sum_(t1 <= t < t2) interfering_workload_of_hep_jobs j t.

  (** ... (f) and cumulative interfering workload. *)
  Let cumulative_interfering_workload (j : Job) (t1 t2 : instant) :=
    \sum_(t1 <= t < t2) interfering_workload j t.

  (** Instantiated functions usually do not have any useful lemmas about them. In order to
     reuse existing lemmas, we need to prove equivalence of the instantiated functions to
     some conventional notions. The instantiations given in this file are equivalent to
     service and workload. Further, we prove these equivalences formally. *)

   (** In order to avoid confusion, we denote the notion of a quiet
        time in the _classical_ sense as [quiet_time_cl], and the
        notion of quiet time in the _abstract_ sense as
        [quiet_time_ab]. *)
    Let quiet_time_cl := busy_interval.quiet_time arr_seq sched.
    Let quiet_time_ab := definitions.quiet_time sched interference interfering_workload.

    (** Same for the two notions of a busy interval. *)
    Let busy_interval_cl := busy_interval.busy_interval arr_seq sched.
    Let busy_interval_ab := definitions.busy_interval sched interference interfering_workload.

  (** Before we present the formal proofs of the equivalences, we recall
     the notion of workload of higher or equal priority jobs. *)
  Let workload_of_other_hep_jobs (j : Job) (t1 t2 : instant) :=
    workload_of_jobs (fun jhp => another_hep_job jhp j) (arrivals_between arr_seq t1 t2).

  (** Similarly, we recall notions of service of higher or equal priority jobs from other tasks... *)
  Let service_of_hep_jobs_from_other_tasks (j : Job) (t1 t2 : instant) :=
    service_of_jobs sched (fun jhp => another_task_hep_job jhp j)
                    (arrivals_between arr_seq t1 t2) t1 t2.

  (** ... and service of all other jobs with higher or equal priority. *)
  Let service_of_other_hep_jobs (j : Job) (t1 t2 : instant) :=
    service_of_jobs sched (fun jhp => another_hep_job jhp j) (arrivals_between arr_seq t1 t2) t1 t2.

  (** ** Equivalences *)
  (** In this section we prove useful equivalences between the
      definitions obtained by instantiation of definitions from the
      Abstract RTA module (interference and interfering workload) and
      definitions corresponding to the conventional concepts.

      As it was mentioned previously, instantiated functions of
      interference and interfering workload usually do not have any
      useful lemmas about them. However, it is possible to prove their
      equivalence to the more conventional notions like service or
      workload. Next we prove the equivalence between the
      instantiations and conventional notions. *)
  Section Equivalences.

    (** In the following subsection, we prove properties of the
        introduced functions under the assumption that the schedule is
        idle. *)
    Section IdleSchedule.

      (** Consider a time instant [t] ... *)
      Variable t : instant.

      (** ... and assume that the schedule is idle at [t]. *)
      Hypothesis H_idle : is_idle sched t.

      (** We prove that in this case: ... *)

      (** ... interference from higher-or-equal priority jobs from
          another task is equal to [false], ... *)
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
forall j : Job,
is_interference_from_hep_job_from_another_task j t =
false

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
forall j : Job,
is_interference_from_hep_job_from_another_task j t =
false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
j: Job
is_interference_from_hep_job_from_another_task j t =
false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
j: Job
match sched t with
| Some jhp => another_task_hep_job jhp j
| None => false
end = false

        by move: (H_idle) => /eqP ->.
      Qed.

      (** ... and interference for a task is equal to [false] as well. *)
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
forall upp : instant,
task_interference_received_before arr_seq sched
  interference tsk upp t = false

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
forall upp : instant,
task_interference_received_before arr_seq sched
  interference tsk upp t = false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
task_interference_received_before arr_seq sched
  interference tsk upp t = false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
~~
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
~~
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
s: Job
IN: s \in task_arrivals_before arr_seq tsk upp
predC (interference^~ t) s

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
s: Job
IN: s \in task_arrivals_before arr_seq tsk upp
~~
(priority_inversion_dec arr_seq sched s t
 || is_interference_from_another_hep_job s t)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
s: Job
IN: s \in task_arrivals_before arr_seq tsk upp
~~ (false || is_interference_from_another_hep_job s t)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t: instant
H_idle: is_idle sched t
upp: instant
s: Job
IN: s \in task_arrivals_before arr_seq tsk upp
~~
(false
 || match sched t with
    | Some jhp => another_hep_job jhp s
    | None => false
    end)

        by move: (H_idle) => /eqP ->.
      Qed.

    End IdleSchedule.

    (** Next, we prove properties of the introduced functions under
        the assumption that the scheduler is not idle. *)
    Section ScheduledJob.

      (** Consider a job [j] of task [tsk]. In this subsection, job
          [j] is deemed to be the main job with respect to which the
          functions are computed. *)
      Variable j : Job.
      Hypothesis H_j_tsk : job_of_task tsk j.

      (** Consider a time instant [t]. *)
      Variable t : instant.

      (** First, consider a case when _some_ jobs is scheduled at time [t]. *)
      Section SomeJobIsScheduled.

        (** Consider a job [j'] (not necessarily distinct from job
           [j]) that is scheduled at time [t]. *)
        Variable j' : Job.
        Hypothesis H_sched : scheduled_at sched j' t.

        (** Under the stated assumptions, we show that the
            interference from another higher-or-equal priority job is
            equal to the relation [another_hep_job]. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_sched: scheduled_at sched j' t
is_interference_from_another_hep_job j t =
another_hep_job j' j

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_sched: scheduled_at sched j' t
is_interference_from_another_hep_job j t =
another_hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_sched: scheduled_at sched j' t
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end = another_hep_job j' j

          by move: (H_sched); rewrite scheduled_at_def; move => /eqP ->.
        Qed.

      End SomeJobIsScheduled.

      (** Next, consider a case when [j] itself is scheduled at [t]. *)
      Section JIsScheduled.

        (** Assume that [j] is scheduled at time [t]. *)
        Hypothesis H_j_sched : scheduled_at sched j t.

        (** Then there is no interference from higher-or-equal
            priority jobs at time [t]. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
H_j_sched: scheduled_at sched j t
is_interference_from_another_hep_job j t = false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
H_j_sched: scheduled_at sched j t
is_interference_from_another_hep_job j t = false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
H_j_sched: scheduled_at sched j t
another_hep_job j j = false

          by rewrite /another_hep_job eq_refl //= Bool.andb_false_r.
        Qed.

      End JIsScheduled.

      (** In the next subsection, we consider a case when a job [j']
          from the same task (as job [j]) is scheduled. *)
      Section FromSameTask.

        (** Consider a job [j'] that comes from task [tsk] and is
            scheduled at time instant [t].  *)
        Variable j' : Job.
        Hypothesis H_j'_tsk : job_of_task tsk j'.
        Hypothesis H_j'_sched : scheduled_at sched j' t.

        (** Then we show that interference from higher-or-equal
            priority jobs from another task is false. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
is_interference_from_hep_job_from_another_task j t =
false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
is_interference_from_hep_job_from_another_task j t =
false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~~ is_interference_from_hep_job_from_another_task j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~~
match sched t with
| Some jhp => another_task_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~~ another_task_hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~~ (job_task j' != job_task j)

          by move: (H_j_tsk) (H_j'_tsk) => /eqP -> /eqP ->; rewrite eq_refl.
        Qed.

        (** Similarly, task interference is equal to false, since in
            order to incur the task interference, a job from a
            distinct task must be scheduled. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
forall upp : instant,
task_interference_received_before arr_seq sched
  interference tsk upp t = false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
forall upp : instant,
task_interference_received_before arr_seq sched
  interference tsk upp t = false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
upp: instant
~~ task_scheduled_at sched tsk t &&
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp) = false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
upp: instant
task_scheduled_at sched tsk t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_tsk: job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
upp: instant
match sched t with
| Some j => job_task j == tsk
| None => false
end

          by move: (H_j'_sched); rewrite scheduled_at_def => /eqP ->.
        Qed.

      End FromSameTask.

      (** In the next subsection, we consider a case when a job [j']
          from a task other than [j]'s task is scheduled. *)
      Section FromDifferentTask.

        (** Consider a job [j'] that _does_ _not_ comes from task
            [tsk] and is scheduled at time instant [t].  *)
        Variable j' : Job.
        Hypothesis H_j'_not_tsk : ~~ job_of_task tsk j'.
        Hypothesis H_j'_sched : scheduled_at sched j' t.

        (** We prove that then [j] incurs higher-or-equal priority
            interference from another task iff [j'] has
            higher-or-equal priority than [j]. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
is_interference_from_hep_job_from_another_task j t =
hep_job j' j

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
is_interference_from_hep_job_from_another_task j t =
hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
match sched t with
| Some jhp => another_task_hep_job jhp j
| None => false
end = hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
another_task_hep_job j' j = hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
true /\ job_task j' != job_task j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~ (false /\ job_task j' != job_task j)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
true /\ job_task j' != job_task j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~ (false /\ job_task j' != job_task j)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~ (false /\ job_task j' != job_task j)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
~ (false /\ job_task j' != job_task j)
 by intros [F _].
        Qed.

        (** Hence, if we assume that [j'] has higher-or-equal priority, ... *)
        Hypothesis H_j'_hep : hep_job j' j.

        (** ... we will be able to show that [j] incurs
            higher-or-equal priority interference from another task. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
is_interference_from_hep_job_from_another_task j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
is_interference_from_hep_job_from_another_task j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
match sched t with
| Some jhp => another_task_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
another_task_hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
true && (job_task j' != job_task j)

          by move: (H_j_tsk) => /eqP ->.
        Qed.

        (** Moreover, in this case, task [tsk] also incurs interference. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
forall upp : instant,
j \in arrivals_between arr_seq 0 upp ->
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
forall upp : instant,
j \in arrivals_between arr_seq 0 upp ->
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
~~ task_scheduled_at sched tsk t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
~~ task_scheduled_at sched tsk t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
j \in task_arrivals_before arr_seq tsk upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
interference j t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
j \in task_arrivals_before arr_seq tsk upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
interference j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
job_of_task tsk j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
interference j t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
interference j t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
interference j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
is_interference_from_another_hep_job j t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
another_hep_job j' j

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_not_tsk: ~~ job_of_task tsk j'
H_j'_sched: scheduled_at sched j' t
H_j'_hep: hep_job j' j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
j' != j

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
H_j'_hep: hep_job j j
H_j'_sched: scheduled_at sched j t
H_j'_not_tsk: ~~ job_of_task tsk j
upp: instant
IN: j \in arrivals_between arr_seq 0 upp
False

              by move: (H_j'_not_tsk); rewrite H_j_tsk.
        Qed.

      End FromDifferentTask.

      (** In the last subsection, we consider a case when the
          scheduled job [j'] has lower priority than job [j]. *)
      Section LowerPriority.

        (** Consider a job [j'] that has lower priority than job [j]
            and is scheduled at time instant [t].  *)
        Variable j' : Job.
        Hypothesis H_j'_sched : scheduled_at sched j' t.
        Hypothesis H_j'_lp : ~~ hep_job j' j.

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_sched: scheduled_at sched j' t
H_j'_lp: ~~ hep_job j' j
is_interference_from_another_hep_job j t = false

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_sched: scheduled_at sched j' t
H_j'_lp: ~~ hep_job j' j
is_interference_from_another_hep_job j t = false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_sched: scheduled_at sched j' t
H_j'_lp: ~~ hep_job j' j
~~ is_interference_from_another_hep_job j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_sched: scheduled_at sched j' t
H_j'_lp: ~~ hep_job j' j
~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_sched: scheduled_at sched j' t
H_j'_lp: ~~ hep_job j' j
~~ another_hep_job j' j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_tsk: job_of_task tsk j
t: instant
j': Job
H_j'_sched: scheduled_at sched j' t
H_j'_lp: ~~ hep_job j' j
HEP: hep_job j' j
False

          by move: H_j'_lp => /negP T; apply: T.
        Qed.

      End LowerPriority.

    End ScheduledJob.

    (** We prove that we can split cumulative interference into two
        parts: (1) cumulative priority inversion and (2) cumulative
        interference from jobs with higher or equal priority. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 t2 : instant),
cumulative_interference j t1 t2 =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1 t2

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 t2 : instant),
cumulative_interference j t1 t2 =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1 t2

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2)
   (is_priority_inversion j t
    || is_interference_from_another_hep_job j t) =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1 t2

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
\sum_(t1 <= t < t2)
   (is_priority_inversion j t
    || is_interference_from_another_hep_job j t) =
\sum_(t1 <= i < t2)
   (is_priority_inversion j i +
    is_interference_from_another_hep_job j i)

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
\sum_(t1 <= t < t2)
   (priority_inversion_dec arr_seq sched j t
    || is_interference_from_another_hep_job j t) =
\sum_(t1 <= i < t2)
   (priority_inversion_dec arr_seq sched j i +
    is_interference_from_another_hep_job j i)

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
priority_inversion_dec arr_seq sched j i
|| is_interference_from_another_hep_job j i <=
priority_inversion_dec arr_seq sched j i +
is_interference_from_another_hep_job j i
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
priority_inversion_dec arr_seq sched j i +
is_interference_from_another_hep_job j i <=
priority_inversion_dec arr_seq sched j i
|| is_interference_from_another_hep_job j i

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
priority_inversion_dec arr_seq sched j i
|| is_interference_from_another_hep_job j i <=
priority_inversion_dec arr_seq sched j i +
is_interference_from_another_hep_job j i
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
IDLE: is_idle sched t
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
IDLE: is_idle sched t
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = true
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = true
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
~~ hep_job s j

            by rewrite PRIO.
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
priority_inversion_dec arr_seq sched j i +
is_interference_from_another_hep_job j i <=
priority_inversion_dec arr_seq sched j i
|| is_interference_from_another_hep_job j i

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
priority_inversion_dec arr_seq sched j i +
is_interference_from_another_hep_job j i <=
priority_inversion_dec arr_seq sched j i
|| is_interference_from_another_hep_job j i
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
IDLE: is_idle sched t
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
IDLE: is_idle sched t
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = true
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = true
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_another_hep_job j t <=
priority_inversion_dec arr_seq sched j t
|| is_interference_from_another_hep_job j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
true + is_interference_from_another_hep_job j t <=
true || is_interference_from_another_hep_job j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
~~ hep_job s j

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
~~ hep_job s j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
s: Job
SCHED: scheduled_at sched s t
PRIO: hep_job s j = false
~~ hep_job s j

            all: by rewrite PRIO.
      }
    Qed.

    (** Similarly, we prove that we can split cumulative interfering
        workload into two parts: (1) cumulative priority inversion and
        (2) cumulative interfering workload from jobs with higher or
        equal priority. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 t2 : nat),
cumul_interfering_workload interfering_workload j t1
  t2 =
cumulative_priority_inversion j t1 t2 +
cumulative_interfering_workload_of_hep_jobs j t1 t2

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 t2 : nat),
cumul_interfering_workload interfering_workload j t1
  t2 =
cumulative_priority_inversion j t1 t2 +
cumulative_interfering_workload_of_hep_jobs j t1 t2

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 t2 : nat),
\sum_(t1 <= t < t2) interfering_workload j t =
\sum_(t1 <= t < t2) is_priority_inversion j t +
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t

      by intros; rewrite -big_split //=.
    Qed.

    (** Let [j] be any job of task [tsk], and let [upp_t] be any time
        instant after job [j]'s arrival. Then for any time interval
        lying before [upp_t], the cumulative interference received by
        [tsk] is equal to the sum of the cumulative priority inversion
        of job [j] and the cumulative interference incurred by task
        [tsk] due to other tasks. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 : nat) (t2 upp_t : instant),
arrives_in arr_seq j ->
job_of_task tsk j ->
j \in arrivals_before arr_seq upp_t ->
~~ job_completed_by j t2 ->
cumulative_task_interference interference tsk upp_t t1
  t2 =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 t2

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
forall (j : Job) (t1 : nat) (t2 upp_t : instant),
arrives_in arr_seq j ->
job_of_task tsk j ->
j \in arrivals_before arr_seq upp_t ->
~~ job_completed_by j t2 ->
cumulative_task_interference interference tsk upp_t t1
  t2 =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 t2

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
\sum_(t1 <= t < R)
   task_interference_received_before arr_seq sched
     interference tsk upp t =
cumulative_priority_inversion j t1 R +
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 R

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
task_interference_received_before arr_seq sched
  interference tsk upp t =
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
task_interference_received_before arr_seq sched
  interference tsk upp t <=
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
task_interference_received_before arr_seq sched
  interference tsk upp t <=
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = true
TSKs: job_task s != tsk
true <=
priority_inversion_dec arr_seq sched j t + true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = true
task_interference_received_before arr_seq sched
  interference tsk upp t <=
true +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
HP: hep_job s j = false
TSKs: (job_task s == tsk) = false
task_interference_received_before arr_seq sched
  interference tsk upp t <=
true +
is_interference_from_hep_job_from_another_task j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
is_priority_inversion j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
~~ hep_job s j +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
~~ ~~ hep_job s j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
NEQ: ~~ hep_job s j
job_completed_by j R
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
NEQ: ~~ hep_job s j
completed_by sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
NEQ: ~~ hep_job s j
NCOMPL: ~~ completed_by sched j t
False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = true
NCOMPL: ~~ completed_by sched j t
job_arrival s <= job_arrival j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
priority_inversion_dec arr_seq sched j t +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
~~ job_of_task tsk s
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ hep_job s j +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ hep_job s j +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ hep_job s j + hep_job s j <=
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
task_interference_received_before arr_seq sched
  interference tsk upp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ task_scheduled_at sched tsk t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ task_scheduled_at sched tsk t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
has (interference^~ t)
  (task_arrivals_before arr_seq tsk upp)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
j \in task_arrivals_before arr_seq tsk upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
interference j t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
j \in task_arrivals_before arr_seq tsk upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
interference j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
j \in arrivals_between arr_seq 0 upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
interference j t

               
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
interference j t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
interference j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ hep_job s j
|| is_interference_from_another_hep_job j t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
~~ hep_job s j
|| match sched t with
   | Some jhp => another_hep_job jhp j
   | None => false
   end

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
HP: hep_job s j = true
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
HP: hep_job s j = true
another_hep_job s j

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
TSK: job_of_task tsk j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
t: nat_eqType
IN: t \in index_iota t1 R
s: Job
Sched_s: scheduled_at sched s t
EqSched_s: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on s (sched t) x) x x
     in F]| <> 0
TSKEQ: (job_task s == job_task j) = false
TSKn: ~~ job_of_task tsk s
HP: hep_job s j = true
s != j

              by apply/eqP; intros EQ; subst s; rewrite TSK in TSKn.
    Qed.

    (** In this section we prove that the (abstract) cumulative interfering workload is equivalent to
       conventional workload, i.e., the one defined with concrete schedule parameters. *)
    Section InstantiatedWorkloadEquivalence.

      (** Let <<[t1,t2)>> be any time interval. *)
      Variables t1 t2 : instant.

      (** Consider any job [j] of [tsk]. *)
      Variable j : Job.
      Hypothesis H_j_arrives : arrives_in arr_seq j.
      Hypothesis H_job_of_tsk : job_of_task tsk j.

      (** Then for any job [j], the cumulative interfering workload is
          equal to the conventional workload. *)
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
cumulative_interfering_workload_of_hep_jobs j t1 t2 =
workload_of_other_hep_jobs j t1 t2

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
cumulative_interfering_workload_of_hep_jobs j t1 t2 =
workload_of_other_hep_jobs j t1 t2

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
cumulative_interfering_workload_of_hep_jobs j t1 t2 =
workload_of_other_hep_jobs j t1 t2

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: (t1 < t2) = false
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: (t1 < t2) = true
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs 
  (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: (t1 < t2) = false
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: t2 <= t1
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: t2 <= t1
0 =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: t2 <= t1
0 = workload_of_jobs (another_hep_job^~ j) [::]

            by rewrite /workload_of_jobs big_nil.
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: (t1 < t2) = true
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: (t1 < t2) = true
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq t1 t2)
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1, t2: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
NEQ: (t1 < t2) = true
\sum_(t1 <= t < t2)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 t2 | another_hep_job
                                               j0 j)
   job_cost j0

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
\sum_(t1 <= t < t1 + k)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) job_cost j0

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
\sum_(t1 <= t < t1 + 0)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + 0) | 
another_hep_job j0 j) job_cost j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < 
t1 + k.+1)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
\sum_(t1 <= t < t1 + 0)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + 0) | 
another_hep_job j0 j) job_cost j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < 
t1 + k.+1)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
\sum_(t1 <= t < t1)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 t1 | another_hep_job
                                               j0 j)
   job_cost j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < 
t1 + k.+1)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
0 =
\sum_(j0 <- arrivals_between arr_seq t1 t1 | another_hep_job
                                               j0 j)
   job_cost j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < 
t1 + k.+1)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
0 =
\sum_(j0 <- [::] | another_hep_job j0 j) job_cost j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < 
t1 + k.+1)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < t1 + k.+1)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) job_cost j0

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= t < t1 + k.+1)
   \sum_(jhp <- arrivals_at arr_seq t | another_hep_job
                                          jhp j)
      job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + k.+1) | 
another_hep_job j0 j) job_cost j0
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(t1 <= i < t1 + k)
   \sum_(jhp <- arrivals_at arr_seq i | another_hep_job
                                          jhp j)
      job_cost jhp +
\sum_(jhp <- arrivals_at arr_seq (t1 + k) | another_hep_job
                                              jhp j)
   job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + k).+1 | 
another_hep_job j0 j) job_cost j0

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) job_cost j0 +
\sum_(jhp <- arrivals_at arr_seq (t1 + k) | another_hep_job
                                              jhp j)
   job_cost jhp =
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + k).+1 | 
another_hep_job j0 j) job_cost j0

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
t1: instant
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
k: nat
IHk: \sum_(t1 <= t < 
t1 + k)
   \sum_(jhp <- 
   arrivals_at arr_seq t | 
   another_hep_job jhp j) 
   job_cost jhp =
\sum_(j0 <- 
arrivals_between arr_seq t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(j0 <- \cat_(t1<=t<t1 + k)arrivals_at arr_seq t | 
another_hep_job j0 j) job_cost j0 +
\sum_(jhp <- arrivals_at arr_seq (t1 + k) | another_hep_job
                                              jhp j)
   job_cost jhp =
\sum_(j0 <- (\cat_(t1<=i<t1 + k)arrivals_at arr_seq i ++
             arrivals_at arr_seq (t1 + k)) | another_hep_job
                                               j0 j)
   job_cost j0

              by rewrite big_cat //=.
        }
      Qed.

    End InstantiatedWorkloadEquivalence.

    (** In this section we prove that the (abstract) cumulative interference of jobs with higher or
       equal priority is equal to total service of jobs with higher or equal priority. *)
    Section InstantiatedServiceEquivalences.

      (** Consider any job [j] of [tsk]. *)
      Variable j : Job.
      Hypothesis H_j_arrives : arrives_in arr_seq j.
      Hypothesis H_job_of_tsk : job_of_task tsk j.

      (** We consider an arbitrary time interval <<[t1, t)>> that starts with a quiet time. *)
      Variable t1 t : instant.
      Hypothesis H_quiet_time : quiet_time_cl j t1.

      (** Then for any job j, the (abstract) instantiated function of interference is
         equal to the total service of jobs with higher or equal priority. *)
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
cumulative_interference_from_other_hep_jobs j t1 t =
service_of_other_hep_jobs j t1 t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
cumulative_interference_from_other_hep_jobs j t1 t =
service_of_other_hep_jobs j t1 t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
cumulative_interference_from_other_hep_jobs j t1 t =
\sum_(j0 <- arrivals_between arr_seq t1 t | another_hep_job
                                              j0 j)
   service_during sched j0 t1 t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= t < t)
   match sched t with
   | Some jhp => another_hep_job jhp j
   | None => false
   end =
\sum_(j0 <- arrivals_between arr_seq t1 t | another_hep_job
                                              j0 j)
   service_during sched j0 t1 t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   match sched i with
   | Some jhp => another_hep_job jhp j
   | None => false
   end =
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   \sum_(i0 <- arrivals_between arr_seq t1 t | another_hep_job
                                                 i0 j)
      service_at sched i0 i

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   match sched i with
   | Some jhp => another_hep_job jhp j
   | None => false
   end <=
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   \sum_(i0 <- arrivals_between arr_seq t1 t | another_hep_job
                                                 i0 j)
      service_at sched i0 i
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= i < t | 
(t1 <= i < t) && true)
   \sum_(i0 <- 
   arrivals_between arr_seq t1 t | 
   another_hep_job i0 j) 
   service_at sched i0 i <=
\sum_(t1 <= i < t | 
(t1 <= i < t) && true)
   match sched i with
   | Some jhp => another_hep_job jhp j
   | None => false
   end

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end <=
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
service_at sched i x <=
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end <=
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end <=
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
another_hep_job jo j <=
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
true <=
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
jo \in arrivals_between arr_seq t1 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
arrived_between jo t1 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
arrived_between jo t1 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
t1 <= job_arrival jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
t1 <= job_arrival jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: jo != j
t1 <= job_arrival jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: jo != j
AB: job_arrival jo < t1
False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: jo != j
AB: job_arrival jo < t1
scheduled_at sched jo x -> False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: jo != j
AB: job_arrival jo < t1
~~ scheduled_at sched jo x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: jo != j
AB: job_arrival jo < t1
completed_by sched jo x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: jo != j
AB: job_arrival jo < t1
completed_by sched jo t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
PRIO: another_hep_job jo j = true
EQ: sched x == Some jo
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
PRIO: another_hep_job jo j = true
EQ: scheduled_at sched jo x
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
PRIO: another_hep_job jo j = true
EQ: has_arrived jo x
job_arrival jo < t

              apply leq_ltn_trans with x; rt_eauto. 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x <=
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   service_at sched i x <=
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (fun i0 : Job => nat_of_bool (sched x == Some i0))
     i <=
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (sched x == Some i) <=
match sched x with
| Some jhp => another_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (Some jo == Some i) <= another_hep_job jo j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (Some jo == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (Some jo == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (sched x == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (sched x == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
?n <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(sched x == Some i) <= 
?n
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
?n <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(sched x == Some i) <= 
?n
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p
  (arrivals_between arr_seq t1 t) x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p
  (arrivals_between arr_seq t1 t) x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
i: Job
(sched x == Some i) <= service_at sched i x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (Some jo == Some i) <= false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
\sum_(i <- arrivals_between arr_seq t1 t | another_hep_job
                                             i j)
   (Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
joo: Job
PRIO2: another_hep_job joo j
(Some jo == Some joo) = 0

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
joo: Job
PRIO2: another_hep_job joo j
C: Some jo = Some joo
False

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_hep_job jo j = false
PRIO2: another_hep_job jo j
False

            by rewrite PRIO2 in PRIO. }
      Qed.

      (** The same applies to the alternative definition of interference. *)
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 t = service_of_hep_jobs_from_other_tasks j t1 t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 t = service_of_hep_jobs_from_other_tasks j t1 t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 t =
\sum_(j0 <- arrivals_between arr_seq t1 t | another_task_hep_job
                                              j0 j)
   service_during sched j0 t1 t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= t < t)
   match sched t with
   | Some jhp => another_task_hep_job jhp j
   | None => false
   end =
\sum_(j0 <- arrivals_between arr_seq t1 t | another_task_hep_job
                                              j0 j)
   service_during sched j0 t1 t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   match sched i with
   | Some jhp => another_task_hep_job jhp j
   | None => false
   end =
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   \sum_(i0 <- arrivals_between arr_seq t1 t | another_task_hep_job
                                                 i0 j)
      service_at sched i0 i

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   match sched i with
   | Some jhp => another_task_hep_job jhp j
   | None => false
   end <=
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   \sum_(i0 <- arrivals_between arr_seq t1 t | another_task_hep_job
                                                 i0 j)
      service_at sched i0 i
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
\sum_(t1 <= i < t | 
(t1 <= i < t) && true)
   \sum_(i0 <- 
   arrivals_between arr_seq t1 t | 
   another_task_hep_job i0 j) 
   service_at sched i0 i <=
\sum_(t1 <= i < t | 
(t1 <= i < t) && true)
   match sched i with
   | Some jhp => another_task_hep_job jhp j
   | None => false
   end

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end <=
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
service_at sched i x <=
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end <=
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end <=
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
another_task_hep_job jo j <=
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
true <=
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
jo \in arrivals_between arr_seq t1 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
arrived_between jo t1 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
arrived_between jo t1 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
t1 <= job_arrival jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
t1 <= job_arrival jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: job_task jo != job_task j
t1 <= job_arrival jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: job_task jo != job_task j
AB: job_arrival jo < t1
False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: job_task jo != job_task j
AB: job_arrival jo < t1
scheduled_at sched jo x -> False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: job_task jo != job_task j
AB: job_arrival jo < t1
~~ scheduled_at sched jo x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: job_task jo != job_task j
AB: job_arrival jo < t1
completed_by sched jo x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO1: hep_job jo j
PRIO2: job_task jo != job_task j
AB: job_arrival jo < t1
completed_by sched jo t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
job_arrival jo < t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
PRIO: another_task_hep_job jo j = true
EQ: scheduled_at sched jo x
job_arrival jo < t

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
PRIO: another_task_hep_job jo j = true
EQ: has_arrived jo x
job_arrival jo < t

              by apply leq_ltn_trans with x; rt_eauto.

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x <=
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   service_at sched i x <=
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (fun i0 : Job => nat_of_bool (sched x == Some i0))
     i <=
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (sched x == Some i) <=
match sched x with
| Some jhp => another_task_hep_job jhp j
| None => false
end

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (Some jo == Some i) <= another_task_hep_job jo j

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (Some jo == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (Some jo == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (sched x == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (sched x == Some i) <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
?n <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(sched x == Some i) <= 
?n
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
?n <= true
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(sched x == Some i) <= 
?n
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p
  (arrivals_between arr_seq t1 t) x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p
  (arrivals_between arr_seq t1 t) x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = true
SCH: unit_service_proc_model (processor_state Job) ->
uniprocessor_model (processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between arr_seq t1 t) ->
service_of_jobs_at sched p
  (arrivals_between arr_seq t1 t) x <= 1
i: Job
(sched x == Some i) <= service_at sched i x
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- 
arrivals_between arr_seq t1 t | 
another_task_hep_job i j) 
(Some jo == Some i) <= false

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (Some jo == Some i) <= false

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
\sum_(i <- arrivals_between arr_seq t1 t | another_task_hep_job
                                             i j)
   (Some jo == Some i) <= false
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
joo: Job
PRIO2: another_task_hep_job joo j
(Some jo == Some joo) = 0

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
joo: Job
PRIO2: another_task_hep_job joo j
C: Some jo = Some joo
False

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
t1, t: instant
H_quiet_time: quiet_time_cl j t1
x: nat
Ge: t1 <= x
Le: x < t
jo: Job
Sched_jo: scheduled_at sched jo x
EqSched_jo: #|[pred x0 |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched x) x0)
       x0 x0 in F]| <> 0
EQ: sched x = Some jo
PRIO: another_task_hep_job jo j = false
PRIO2: another_task_hep_job jo j
False

              by rewrite PRIO2 in PRIO.
        }
      Qed.

      End InstantiatedServiceEquivalences.

      (** In this section we prove that the abstract definition of busy interval is equivalent to
         the conventional, concrete definition of busy interval for JLFP scheduling. *)
      Section BusyIntervalEquivalence.

        (** Consider any job j of [tsk]. *)
        Variable j : Job.
        Hypothesis H_j_arrives : arrives_in arr_seq j.
        Hypothesis H_job_of_tsk : job_of_task tsk j.
        Hypothesis H_job_cost_positive : job_cost_positive j.

        (** To show the equivalence of the notions of busy intervals
            we first show that the notions of quiet time are also
            equivalent. *)

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_cl j t -> quiet_time_ab j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_cl j t -> quiet_time_ab j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall j : Job, quiet_time_cl j 0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
forall t : instant,
quiet_time_cl j t -> quiet_time_ab j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall j : Job, quiet_time_cl j 0
 by intros jhp ARR HP AB; move: AB; rewrite /arrived_before ltn0. 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
forall t : instant,
quiet_time_cl j t -> quiet_time_ab j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
~~ pending_earlier_and_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
~~ pending_earlier_and_at sched j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
~~ arrived_before j t \/ completed_by sched j t

            by case ARR: (arrived_before j t); [right | left]; [apply QT | ]; eauto.
          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
cumulative_interference_from_other_hep_jobs j 0 t ==
cumulative_interfering_workload_of_hep_jobs j 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
workload_of_other_hep_jobs j 0 t =
service_of_other_hep_jobs j 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
forall j0 : Job,
j0 \in arrivals_between arr_seq 0 t ->
another_hep_job j0 j -> completed_by sched j0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrives_in arr_seq j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
hep_job j0 j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrived_before j0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrives_in arr_seq j0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
hep_job j0 j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrived_before j0 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
hep_job j0 j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrived_before j0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
hep_job j0 j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrived_before j0 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrived_before j0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
QT: quiet_time_cl j t
j0: Job
IN: j0 \in arrivals_between arr_seq 0 t
HEP: another_hep_job j0 j
arrived_before j0 t
 by apply in_arrivals_implies_arrived_between in IN; rt_eauto.
          }
        Qed.

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
forall j : Job, quiet_time_cl j 0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
forall j : Job, quiet_time_cl j 0
 by intros jhp ARR HP AB; move: AB; rewrite /arrived_before ltn0. 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
completed_by sched jhp t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
workload_of_jobs (hep_job^~ j)
  (arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
workload_of_jobs (hep_job^~ j)
  (arrivals_between arr_seq 0 t) =
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && (j0 != j))
  (arrivals_between arr_seq 0 t) +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq 0 t) +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
service_of_jobs sched (another_hep_job^~ j)
  (arrivals_between arr_seq 0 t) 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
workload_of_jobs (another_hep_job^~ j)
  (arrivals_between arr_seq 0 t) +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
T1: ~~ pending_earlier_and_at sched j t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
{in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1 pred0}
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1
  pred0}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
{in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1 pred0}
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
j__copy: Job
IN: j__copy \in arrivals_between arr_seq 0 t
~~ (hep_job j__copy j && ~~ (j__copy != j))

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
IN: j \in arrivals_between arr_seq 0 t
False

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
IN: j \in arrivals_between arr_seq 0 t
arrived_before j t

              by apply in_arrivals_implies_arrived_between in IN; rt_eauto. 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1
  pred0}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1
  pred0}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched pred0
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1
  pred0}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs pred0 (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched pred0
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1
  pred0}
EQ: cumulative_interference_from_other_hep_jobs j 0 t =
cumulative_interfering_workload_of_hep_jobs j 0 t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs pred0 (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched pred0
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
NA: ~~ arrived_before j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j__copy : Job =>
   hep_job j__copy j && ~~ (j__copy != j)) =1
  pred0}
workload_of_jobs pred0 (arrivals_between arr_seq 0 t) ==
service_of_jobs sched pred0
  (arrivals_between arr_seq 0 t) 0 t

            by erewrite workload_of_jobs_pred0, service_of_jobs_pred0.
          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
{in arrivals_between arr_seq 0 t,
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j)) =1
  eq_op j}
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
{in arrivals_between arr_seq 0 t,
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j)) =1
  eq_op j}
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
j__copy: Job
IN: j__copy \in arrivals_between arr_seq 0 t
hep_job j__copy j && ~~ (j__copy != j) =
(j == j__copy)

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
j__copy: Job
IN: j__copy \in arrivals_between arr_seq 0 t
hep_job j__copy j && (j__copy == j) = (j == j__copy)

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
j__copy: Job
IN: j__copy \in arrivals_between arr_seq 0 t
EQ: (j == j__copy) = true
hep_job j__copy j && true = true

              
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j__copy: Job
H_job_cost_positive: job_cost_positive j__copy
H_j_arrives: arrives_in arr_seq j__copy
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j__copy 0 t =
cumul_interfering_workload interfering_workload
  j__copy 0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j__copy
ARB: arrived_before jhp t
COMP: completed_by sched j__copy t
IN: j__copy \in arrivals_between arr_seq 0 t
hep_job j__copy j__copy

              by eapply (H_priority_is_reflexive 0). 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs
  (fun j0 : Job => hep_job j0 j && ~~ (j0 != j))
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched (eq_op j)
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
T0: cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j
  0 t
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs (eq_op j)
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched (eq_op j)
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
EQ: cumulative_interference_from_other_hep_jobs j 0 t =
cumulative_interfering_workload_of_hep_jobs j 0 t
cumulative_interfering_workload_of_hep_jobs j 0 t +
workload_of_jobs (eq_op j)
  (arrivals_between arr_seq 0 t) =
cumulative_interference_from_other_hep_jobs j 0 t +
service_of_jobs sched (eq_op j)
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
workload_of_jobs (eq_op j)
  (arrivals_between arr_seq 0 t) ==
service_of_jobs sched (eq_op j)
  (arrivals_between arr_seq 0 t) 0 t

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
zero_is_quiet_time: forall j : Job, quiet_time_cl j 0
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
COMP: completed_by sched j t
PRED__eq: {in arrivals_between arr_seq 0 t,
  (fun j0 : Job =>
   hep_job j0 j && ~~ (j0 != j)) =1 
  eq_op j}
forall j0 : Job,
j0 \in arrivals_between arr_seq 0 t ->
j == j0 -> completed_by sched j0 t

            by move => j__copy _ /eqP EQ; subst j__copy. }
        Qed.

        (** The equivalence trivially follows from the lemmas above. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_cl j t <-> quiet_time_ab j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_cl j t <-> quiet_time_ab j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
forall t : instant,
quiet_time_cl j t <-> quiet_time_ab j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t: instant
quiet_time_cl j t -> quiet_time_ab j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t: instant
quiet_time_ab j t -> quiet_time_cl j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t: instant
quiet_time_cl j t -> quiet_time_ab j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t: instant
quiet_time_ab j t -> quiet_time_cl j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t: instant
quiet_time_ab j t -> quiet_time_cl j t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t: instant
quiet_time_ab j t -> quiet_time_cl j t
 apply quiet_time_ab_implies_quiet_time_cl.
        Qed.

        (** Based on that, we prove that the concept of busy interval obtained by instantiating the abstract
           definition of busy interval coincides with the conventional definition of busy interval. *)
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t1 t2 : instant,
busy_interval_cl j t1 t2 <-> busy_interval_ab j t1 t2

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_job_cost_positive: job_cost_positive j
forall t1 t2 : instant,
busy_interval_cl j t1 t2 <-> busy_interval_ab j t1 t2

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
forall t1 t2 : instant,
busy_interval_cl j t1 t2 <-> busy_interval_ab j t1 t2

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
busy_interval_cl j t1 t2 -> busy_interval_ab j t1 t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
busy_interval_ab j t1 t2 -> busy_interval_cl j t1 t2

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
busy_interval_cl j t1 t2 -> busy_interval_ab j t1 t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
busy_interval_ab j t1 t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ: t1 < t2
QTt1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
REL: t1 <= job_arrival j < t2
QTt2: quiet_time arr_seq sched j t2
definitions.quiet_time sched interference
  interfering_workload j t2
 by eapply instantiated_quiet_time_equivalent_quiet_time in QTt2.
          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
busy_interval_ab j t1 t2 -> busy_interval_cl j t1 t2

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
busy_interval_ab j t1 t2 -> busy_interval_cl j t1 t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
busy_interval_cl j t1 t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
t1 <= job_arrival j < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2

            
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
NEQ1: t1 <= job_arrival j
NEQ2: job_arrival j < t2
QTt1: definitions.quiet_time sched interference
  interfering_workload j t1
NQT: forall t : nat,
t1 < t < t2 ->
~
definitions.quiet_time sched interference
  interfering_workload j t
QTt2: definitions.quiet_time sched interference
  interfering_workload j t2
quiet_time arr_seq sched j t2
 by eapply instantiated_quiet_time_equivalent_quiet_time; eauto 2.
          }
        Qed.

      End BusyIntervalEquivalence.

  End Equivalences.

  (** In this section we prove some properties about the interference
      and interfering workload as defined in this file. *)
  Section I_IW_correctness.

    (** Consider work-bearing readiness. *)
    Context `{@JobReady Job (ideal.processor_state Job) _ _}.
    Hypothesis H_work_bearing_readiness : work_bearing_readiness arr_seq sched.

    (** Assume that the schedule is valid and work-conserving. *)
    Hypothesis H_sched_valid :  @valid_schedule Job (ideal.processor_state Job) sched _ _ _ arr_seq.

    (** Note that we differentiate between abstract and classical
        notions of work conserving schedule. *)
    Let work_conserving_ab := definitions.work_conserving arr_seq sched interference interfering_workload.
    Let work_conserving_cl := work_conserving.work_conserving arr_seq sched.

  (** We assume that the schedule is a work-conserving schedule in the
      _classical_ sense, and later prove that the hypothesis about
      abstract work-conservation also holds. *)
    Hypothesis H_work_conserving : work_conserving_cl.

    (** Assume the scheduling policy under consideration is reflexive. *)
    Hypothesis policy_reflexive : reflexive_priorities.

    (** In this section, we prove the correctness of interference
        inside the busy interval, i.e., we prove that if interference
        for a job is [false] then the job is scheduled and vice versa.
        This property is referred to as abstract work conservation. *)

    Section Abstract_Work_Conservation.

      (** Consider a job [j] that is in the arrival sequence
          and has a positive job cost. *)
      Variable j : Job.
      Hypothesis H_arrives : arrives_in arr_seq j.
      Hypothesis H_job_cost_positive : 0 < job_cost j.

      (** Let the busy interval of the job be <<[t1,t2)>>. *)
      Variable t1 t2 : instant.
      Hypothesis H_busy_interval : busy_interval_ab j t1 t2.

      (** Consider a time [t] inside the busy interval of the job. *)
      Variable t : instant.
      Hypothesis H_t_in_busy_interval : t1 <= t < t2.

    (** First, we prove that if interference is [false] at a time [t]
        then the job is scheduled. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
~ interference j t -> scheduled_at sched j t

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
~ interference j t -> scheduled_at sched j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
~~ interference j t -> scheduled_at sched j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
~~ priority_inversion_dec arr_seq sched j t &&
~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end -> scheduled_at sched j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
scheduled_at sched j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
Idle: is_idle sched t
EqIdle: sched t = None
scheduled_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
jo: Job
Sched_jo: scheduled_at sched jo t
EqSched_jo: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched t) x) x
       x in F]| <> 0
scheduled_at sched j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
Idle: is_idle sched t
EqIdle: sched t = None
scheduled_at sched j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
Idle: is_idle sched t
EqIdle: sched t = None
False

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_cl j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
Idle: is_idle sched t
EqIdle: sched t = None
False

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_cl j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
Idle: is_idle sched t
EqIdle: sched t = None
PREF: busy_interval_prefix arr_seq sched j t1 t2
False

        eapply not_quiet_implies_not_idle; rt_eauto. 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
jo: Job
Sched_jo: scheduled_at sched jo t
EqSched_jo: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched t) x) x
       x in F]| <> 0
scheduled_at sched j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
jo: Job
Sched_jo: scheduled_at sched jo t
EqSched_jo: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jo (sched t) x) x
       x in F]| <> 0
scheduled_at sched j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
jo: Job
EqSched_jo: sched t = Some jo
scheduled_at sched j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
HYP2: ~~ another_hep_job jo j
scheduled_at sched j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: ~~ hep_job jo j
scheduled_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
EQ: ~~ (jo != j)
scheduled_at sched j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: ~~ hep_job jo j
scheduled_at sched j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: priority_inversion_dec arr_seq sched j ?t
scheduled_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: ~~ hep_job jo j
scheduled_at sched jo ?t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: priority_inversion_dec arr_seq sched j ?t
scheduled_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: ~~ hep_job jo j
scheduled_at sched jo ?t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: ~~ hep_job jo j
scheduled_at sched jo ?t

          
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
NHEP: ~~ hep_job jo j
scheduled_at sched jo ?t
 by erewrite scheduled_at_def, EqSched_jo.
        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
EQ: ~~ (jo != j)
scheduled_at sched j t

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
EQ: ~~ (jo != j)
scheduled_at sched j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
jo: Job
EqSched_jo: sched t = Some jo
HYP1: ~~ priority_inversion_dec arr_seq sched j t
EQ: jo = j
scheduled_at sched j t

          by subst jo; rewrite scheduled_at_def EqSched_jo.
        }
      }
    Qed.

    (** Conversely, if the job is scheduled at [t] then interference is [false]. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
scheduled_at sched j t -> ~ interference j t

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
scheduled_at sched j t -> ~ interference j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~ interference j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ interference j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ priority_inversion_dec arr_seq sched j t &&
~~ another_hep_job j j

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ priority_inversion_dec arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ priority_inversion_dec arr_seq sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
scheduled_at sched ?j' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
hep_job ?j' j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
scheduled_at sched ?j' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
hep_job ?j' j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
hep_job j j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ another_hep_job j j
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
H_arrives: arrives_in arr_seq j
H_job_cost_positive: 0 < job_cost j
t1, t2: instant
H_busy_interval: busy_interval_ab j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
HYP: sched t = Some j
~~ hep_job j j || ~~ (j != j)

        by apply /orP; right; apply /negPn.
    Qed.

    End Abstract_Work_Conservation.

    (** Using the above two lemmas, we can prove that abstract work conservation
        always holds for these instantiations of [I] and [IW]. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
work_conserving_ab

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
work_conserving_ab

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
t1, t2: instant
t: nat
ARR: arrives_in arr_seq j
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
NEQ: t1 <= t < t2
~ interference j t -> scheduled_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
t1, t2: instant
t: nat
ARR: arrives_in arr_seq j
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
NEQ: t1 <= t < t2
scheduled_at sched j t -> ~ interference j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
t1, t2: instant
t: nat
ARR: arrives_in arr_seq j
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
NEQ: t1 <= t < t2
~ interference j t -> scheduled_at sched j t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
t1, t2: instant
t: nat
ARR: arrives_in arr_seq j
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
NEQ: t1 <= t < t2
scheduled_at sched j t -> ~ interference j t
 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
t1, t2: instant
t: nat
ARR: arrives_in arr_seq j
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
NEQ: t1 <= t < t2
scheduled_at sched j t -> ~ interference j t

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
j: Job
t1, t2: instant
t: nat
ARR: arrives_in arr_seq j
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
NEQ: t1 <= t < t2
scheduled_at sched j t -> ~ interference j t
 by apply (scheduled_implies_no_interference j t ); try done.
    Qed.

    (** Next, in order to prove that these definitions of [I] and [IW] are consistent
        with sequential tasks, we need to assume that the policy under consideration
        respects sequential tasks. *)
    Hypothesis H_policy_respects_sequential_tasks : policy_respects_sequential_tasks.

    (** We prove that these definitions of [I] and [IW] are consistent with sequential
        tasks. *)
    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
interference_and_workload_consistent_with_sequential_tasks
  arr_seq sched tsk interference interfering_workload

    
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
interference_and_workload_consistent_with_sequential_tasks
  arr_seq sched tsk interference interfering_workload

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
task_workload_between arr_seq tsk 0 t1 =
task_service_of_jobs_in sched tsk
  (arrivals_between arr_seq 0 t1) 0 t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
task_workload_between arr_seq tsk 0 t1 =
task_service_of_jobs_in sched tsk
  (arrivals_between arr_seq 0 t1) 0 t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
forall j : Job,
j \in arrivals_between arr_seq 0 t1 ->
job_of_task tsk j -> completed_by sched j t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
completed_by sched s t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
NEQ: s \in arrivals_between arr_seq 0 t1
completed_by sched s t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
NEQ: arrived_between s 0 t1
completed_by sched s t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
JAs: job_arrival s < t1
completed_by sched s t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
JAs: job_arrival s < t1
QT: quiet_time arr_seq sched j t1
JAj: t1 <= job_arrival j
completed_by sched s t1

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
JAs: job_arrival s < t1
QT: quiet_time arr_seq sched j t1
JAj: t1 <= job_arrival j
hep_job s j

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
j: Job
t1, t2: instant
ARR: arrives_in arr_seq j
TSK: job_task j = tsk
POS: 0 < job_cost j
BUSY: busy_interval_cl j t1 t2
s: Job
INs: s \in arrivals_between arr_seq 0 t1
TSKs: job_task s = tsk
JAs: job_arrival s < t1
QT: quiet_time arr_seq sched j t1
JAj: t1 <= job_arrival j
job_arrival s <= job_arrival j

      by apply leq_trans with t1; [lia | done].
    Qed.

    (** Since interfering and interfering workload are sufficient to define the busy window,
        next, we reason about the bound on the length of the busy window. *)
    Section BusyWindowBound.

      (** Consider an arrival curve. *)
      Context `{MaxArrivals Task}.

      (** Consider a set of tasks that respects the arrival curve. *)
      Variable ts : list Task.
      Hypothesis H_taskset_respects_max_arrivals : taskset_respects_max_arrivals arr_seq ts.

      (** Assume that all jobs come from this task set. *)
      Hypothesis H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts.

      (** Consider a constant [L] such that... *)
      Variable L : duration.
      (** ... [L] is greater than [0], and... *)
      Hypothesis H_L_positive : L > 0.

      (** [L] is the fixed point of the following equation. *)
      Hypothesis H_fixed_point : L = total_request_bound_function ts L.

      (** Assume all jobs have a valid job cost. *)
      Hypothesis H_arrivals_have_valid_job_costs : arrivals_have_valid_job_costs arr_seq.

      (** Then, we prove that [L] is a bound on the length of the busy window. *)
      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L

      
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
forall t : instant,
workload_of_jobs predT
  (arrivals_between arr_seq t (t + L)) <= L
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
forall t : instant,
workload_of_jobs predT
  (arrivals_between arr_seq t (t + L)) <= L
 intros; rewrite {2}H_fixed_point; apply total_workload_le_total_rbf; try by done. 
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2

        
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_valid_arrival_sequence: valid_arrival_sequence
  arr_seq
sched: schedule (processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
is_priority_inversion:= fun j : Job =>
[eta priority_inversion_dec
       arr_seq sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between
     arr_seq t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (another_task_hep_job^~ j)
  (arrivals_between
     arr_seq t1
     t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between arr_seq
     t1 t2) t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
policy_reflexive: reflexive_priorities
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
H5: MaxArrivals Task
ts: seq Task
H_taskset_respects_max_arrivals: taskset_respects_max_arrivals
  arr_seq ts
H_all_jobs_from_taskset: all_jobs_from_taskset
  arr_seq ts
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
H_arrivals_have_valid_job_costs: arrivals_have_valid_job_costs
  arr_seq
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
definitions.busy_interval sched interference
  interfering_workload j t1 t2

        by eapply instantiated_busy_interval_equivalent_busy_interval; rt_eauto.
      Qed.

    End BusyWindowBound.

  End I_IW_correctness.

End JLFPInstantiation.

Global Opaque is_interference_from_another_hep_job.