From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
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]
Require Export prosa.analysis.definitions.priority_inversion.
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]
Require Export prosa.analysis.abstract.abstract_seq_rta.
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]
Require Export prosa.analysis.facts.busy_interval.busy_interval.
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]
Require Export prosa.analysis.facts.busy_interval.quiet_time.
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]
Require Export prosa.analysis.definitions.work_bearing_readiness.
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]
Require Export prosa.model.priority.classes.
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 arrival sequence with consistent arrivals. *)
  Variable arr_seq : arrival_sequence Job.
  Hypothesis H_arrival_times_are_consistent : consistent_arrival_times arr_seq.
  Hypothesis H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq. 
  
  (** Next, consider 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 or 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 arrivals_between := arrivals_between arr_seq.
  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. *)

  (** For proper calculation of interference and interfering workload
     of a job, we need to distinguish interference received from other
     jobs of the same task and jobs of other tasks. In that regard, we
     introduce two additional relations. The first relation defines
     whether job [j1] has a higher-than-or-equal-priority than job [j2]
     and [j1] is not equal to [j2]... *)
  Let another_hep_job: JLFP_policy Job :=
    fun j1 j2 => hep_job j1 j2 && (j1 != j2).

  (** ...and the second relation defines whether a job [j1] has a higher-or-equal-priority than 
     job [j2] and the task of [j1] is not equal to task of [j2]. *)
  Let hep_job_from_another_task: JLFP_policy Job :=
    fun j1 j2 => hep_job j1 j2 && (job_task j1 != job_task j2).

  (** In order to introduce the interference, first we need to recall the definition 
     of priority inversion introduced in module analysis.definitions.priority_inversion:
        [ Definition is_priority_inversion t := ]
        [   if sched t is Some jlp then         ]
        [     ~~ higher_eq_priority jlp j       ]
        [   else false.                         ]
     I.e., 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) :=
    is_priority_inversion 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
      hep_job_from_another_task 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 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 => hep_job_from_another_task jhp j)
                    (arrivals_between 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 t1 t2) t1 t2.
    
  (** ** Equivalences *)
  (** In this section we prove a few 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.
    
    (** 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. *)
    Lemma cumulative_interference_split:
      forall j t1 t2,
        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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
      rewrite /cumulative_interference /interference.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
      intros; rewrite -big_split //=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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)
      apply/eqP; rewrite eqn_leq; apply/andP; split; rewrite leq_sum; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
is_priority_inversion j i
|| is_interference_from_another_hep_job j i <=
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
is_priority_inversion j i +
is_interference_from_another_hep_job j i <=
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
is_priority_inversion j i
|| is_interference_from_another_hep_job j i <=
is_priority_inversion j i +
is_interference_from_another_hep_job j i intros t _; unfold is_priority_inversion, priority_inversion.is_priority_inversion.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end || is_interference_from_another_hep_job j t <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end + is_interference_from_another_hep_job j t
        ideal_proc_model_sched_case_analysis_eq sched t s; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end || is_interference_from_another_hep_job j t <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end + is_interference_from_another_hep_job j t
        destruct (hep_job s j) eqn:MM; simpl; rewrite ?addn0 ?add0n.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
MM: hep_job s j = true
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end || is_interference_from_another_hep_job j t <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end + 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
MM: hep_job s j = false
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end || is_interference_from_another_hep_job j t <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end + is_interference_from_another_hep_job j t
        all: by move: Sched_s; rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ MM.
      }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
is_priority_inversion j i +
is_interference_from_another_hep_job j i <=
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
forall i : nat,
true ->
is_priority_inversion j i +
is_interference_from_another_hep_job j i <=
is_priority_inversion j i
|| is_interference_from_another_hep_job j i intros t _; unfold is_priority_inversion, priority_inversion.is_priority_inversion,
                    is_interference_from_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end
|| match sched t with
   | Some jhp => another_hep_job jhp j
   | None => false
   end
        ideal_proc_model_sched_case_analysis_eq sched t s; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end
|| match sched t with
   | Some jhp => another_hep_job jhp j
   | None => false
   end
        unfold 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end
|| match sched t with
   | Some jhp => hep_job jhp j && (jhp != j)
   | None => false
   end
        destruct (hep_job s j) eqn:HP; simpl; rewrite ?addn0 ?add0n.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end
|| match sched t with
   | Some jhp => hep_job jhp j && (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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1, t2: instant
t: nat
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
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end
|| match sched t with
   | Some jhp => hep_job jhp j && (jhp != j)
   | None => false
   end
        all: by move: Sched_s; rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ HP.
      }
    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. *)
    Lemma cumulative_task_interference_split: 
      forall j t1 t2 upp_t,
        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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
      rewrite /cumulative_task_interference /cumul_task_interference.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 ->
\sum_(t1 <= t < t2)
   task_interference_received_before arr_seq sched
     interference tsk upp_t t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_hep_jobs_from_other_tasks
  j t1 t2
      intros j t1 R upp ARRin TSK ARR NCOMPL; move: TSK => /eqP TSK.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\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
      rewrite -big_split //= big_nat_cond [X in _ = X]big_nat_cond.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     interference tsk upp i =
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   (is_priority_inversion j i +
    is_interference_from_hep_job_from_another_task j i) 
      apply/eqP; rewrite eqn_leq; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     interference tsk upp i <=
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   (is_priority_inversion j i +
    is_interference_from_hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (is_priority_inversion j i +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     interference tsk upp i
      all: rewrite /interference /is_priority_inversion /priority_inversion.is_priority_inversion.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || is_interference_from_another_hep_job j t)
     tsk upp i <=
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || is_interference_from_another_hep_job j t)
     tsk upp i <=
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i apply leq_sum; intros t _.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
task_interference_received_before arr_seq sched
  (fun (j : Job) (t : instant) =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end || is_interference_from_another_hep_job j t)
  tsk upp t <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
        rewrite /task_interference_received_before /task_schedule.task_scheduled_at
                /is_interference_from_hep_job_from_another_task
                /is_interference_from_another_hep_job /hep_job_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has
  (fun j : Job =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end
   || match sched t with
      | Some jhp => another_hep_job jhp j
      | None => false
      end) (task_arrivals_before arr_seq tsk upp) <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp =>
    hep_job jhp j && (job_task jhp != job_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
        ideal_proc_model_sched_case_analysis_eq sched t s; first by rewrite has_pred0 addn0 leqn0 eqb0.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
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
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has
  (fun j : Job =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end
   || match sched t with
      | Some jhp => another_hep_job jhp j
      | None => false
      end) (task_arrivals_before arr_seq tsk upp) <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp =>
    hep_job jhp j && (job_task jhp != job_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i 
        destruct (hep_job s j) eqn:HP; simpl.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
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
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has
  (fun j : Job =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end
   || match sched t with
      | Some jhp => another_hep_job jhp j
      | None => false
      end) (task_arrivals_before arr_seq tsk upp) <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp =>
    hep_job jhp j && (job_task jhp != job_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
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
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has
  (fun j : Job =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end
   || match sched t with
      | Some jhp => another_hep_job jhp j
      | None => false
      end) (task_arrivals_before arr_seq tsk upp) <=
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp =>
    hep_job jhp j && (job_task jhp != job_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
        1-2: move: Sched_s; rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ HP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ true + true && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ false + false && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
        +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ true + true && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ false + false && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i rewrite add0n TSK.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
true && (job_task s != tsk)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ false + false && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
          by case: (job_task s != tsk); first rewrite Bool.andb_true_l leq_b1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ false + false && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i
        +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
s: Job
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
EQ: sched t = Some s
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j || another_hep_job s j)
  (task_arrivals_before arr_seq tsk upp) <=
~~ false + false && (job_task s != 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | 
(t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || 
      is_interference_from_another_hep_job j t) tsk
     upp i by rewrite addn0 leq_b1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || is_interference_from_another_hep_job j t)
     tsk upp i 
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   (match sched i with
    | Some jlp => ~~ hep_job jlp j
    | None => false
    end +
    is_interference_from_hep_job_from_another_task j i) <=
\sum_(t1 <= i < R | (t1 <= i < R) && true)
   task_interference_received_before arr_seq sched
     (fun (j : Job) (t : instant) =>
      match sched t with
      | Some jlp => ~~ hep_job jlp j
      | None => false
      end || is_interference_from_another_hep_job j t)
     tsk upp i apply leq_sum; move => t /andP [/andP [_ LT'] _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < R
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
is_interference_from_hep_job_from_another_task j t <=
task_interference_received_before arr_seq sched
  (fun (j : Job) (t : instant) =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end || is_interference_from_another_hep_job j t)
  tsk upp t
        rewrite /is_interference_from_hep_job_from_another_task
                /hep_job_from_another_task /task_interference_received_before
                /task_schedule.task_scheduled_at.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < R
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp =>
    hep_job jhp j && (job_task jhp != job_task j)
| None => false
end <=
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has
  (fun j : Job =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq tsk upp)
        ideal_proc_model_sched_case_analysis_eq sched t s; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end +
match sched t with
| Some jhp =>
    hep_job jhp j && (job_task jhp != job_task j)
| None => false
end <=
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has
  (fun j : Job =>
   match sched t with
   | Some jlp => ~~ hep_job jlp j
   | None => false
   end || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq tsk upp)
        move: (Sched_s); rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
~~ hep_job s j +
hep_job s j && (job_task s != job_task j) <=
(job_task s != tsk) &&
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq tsk upp)
        rewrite -TSK; case TSKEQ: (job_task s == job_task j); simpl.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = true
~~ hep_job s j + hep_job s j && false <= 0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp) 
        +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = true
~~ hep_job s j + hep_job s j && false <= 0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp) rewrite Bool.andb_false_r leqn0 addn0 eqb0.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          apply/negP; intros NEQ; move: NCOMPL => /negP NCOMPL; apply: NCOMPL.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          apply completion_monotonic with t; [ by apply ltnW | ].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          apply/negP; intros NCOMPL; move: NCOMPL => /negP NCOMPL.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          move: NEQ => /negP NEQ; apply: NEQ; apply H_JLFP_respects_sequential_tasks; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp) 
          by eapply scheduler_executes_job_with_earliest_arrival; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
        +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp) have NEQ: 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
s != j apply/negP; intros EQ2; move: EQ2 => /eqP EQ2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
EQ2: s = j
False
              by move: TSKEQ => /eqP TSKEQ; apply: TSKEQ; rewrite EQ2. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp) 
          have Fact: forall b, ~~ b + b = true; first by intros b; destruct b.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
Fact: forall b : bool, ~~ b + b = true
~~ hep_job s j + hep_job s j && true <=
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          rewrite Bool.andb_true_r Fact; simpl; rewrite lt0b; clear Fact.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
has
  (fun j : Job =>
   ~~ hep_job s j
   || is_interference_from_another_hep_job j t)
  (task_arrivals_before arr_seq (job_task j) upp)
          apply/hasP; exists j.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
j \in task_arrivals_before arr_seq (job_task j) upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
j \in task_arrivals_before arr_seq (job_task j) upp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ hep_job s j
|| is_interference_from_another_hep_job j t rewrite mem_filter; apply/andP; split; first by rewrite TSK; apply/eqP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
j \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ hep_job s j
|| is_interference_from_another_hep_job j t
            exact: arrivals_between_sub ARR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
~~ hep_job s j
|| is_interference_from_another_hep_job j t destruct (hep_job s j) eqn:HP; apply/orP; [right|left]; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
j: Job
t1: nat
R, upp: instant
ARRin: arrives_in arr_seq j
ARR: j \in arrivals_before arr_seq upp
NCOMPL: ~~ job_completed_by j R
TSK: job_task j = tsk
t: nat
LT': t < 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
EQ: sched t = Some s
TSKEQ: (job_task s == job_task j) = false
NEQ: s != j
HP: hep_job s j = true
is_interference_from_another_hep_job j t
            by rewrite /is_interference_from_another_hep_job EQ
                       /another_hep_job NEQ Bool.andb_true_r. 
    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. *)
      Lemma instantiated_cumulative_workload_of_hep_jobs_equal_total_workload_of_hep_jobs:
        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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        intros.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        rewrite /cumulative_interfering_workload_of_hep_jobs
                /workload_of_other_hep_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t2)
        case NEQ: (t1 < t2); last first.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t2) move: NEQ => /negP /negP; rewrite -leqNgt; move => NEQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t2)
          rewrite big_geq; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t2)
          rewrite /arrivals_between /arrival_sequence.arrivals_between big_geq; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t2) unfold interfering_workload_of_hep_jobs, workload_of_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t2 | another_hep_job
                                       j0 j)
   job_cost j0
          interval_to_duration t1 t2 k.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 (t1 + k) | another_hep_job
                                             j0 j)
   job_cost j0
          induction k.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0 rewrite !addn0.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0
            rewrite big_geq; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0
            rewrite /arrivals_between /arrival_sequence.arrivals_between big_geq; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 t1 (t1 + k.+1) | 
another_hep_job j0 j) 
job_cost j0
              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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 t1 (t1 + k.+1) | another_hep_job
                                                j0 j)
   job_cost j0 rewrite addnS big_nat_recr //=; last by rewrite leq_addr.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 t1 (t1 + k).+1 | another_hep_job
                                                j0 j)
   job_cost j0
            rewrite IHk.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 (t1 + k) | 
another_hep_job j0 j) 
job_cost j0
\sum_(j0 <- arrivals_between 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 t1 (t1 + k).+1 | another_hep_job
                                                j0 j)
   job_cost j0
            rewrite /arrivals_between /arrival_sequence.arrivals_between big_nat_recr //=; 
                    last by rewrite leq_addr.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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. *)
      Lemma instantiated_cumulative_interference_of_hep_jobs_equal_total_interference_of_hep_jobs:
        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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        rewrite /service_of_other_hep_jobs /service_of_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job j0
                                      j)
   service_during sched j0 t1 t
        rewrite /cumulative_interference_from_other_hep_jobs
                /is_interference_from_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job j0
                                      j)
   service_during sched j0 t1 t
        rewrite exchange_big //= big_nat_cond [in X in _ = X]big_nat_cond.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job
                                         i0 j)
      service_at sched i0 i
        all: apply/eqP; rewrite eqn_leq; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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
        all: rewrite leq_sum //; move => x /andP [/andP [Ge Le] _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job i j)
   service_at sched i x ideal_proc_model_sched_case_analysis_eq sched x jo; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job i j)
   service_at sched i x
          move: (Sched_jo); rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job i j)
   service_at sched i x
          destruct (another_hep_job jo j) eqn:PRIO; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job i j)
   service_at sched i x
          rewrite (big_rem jo) /=; first by rewrite PRIO service_at_def EQ eq_refl.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t
          apply arrived_between_implies_in_arrivals; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
arrives_in arr_seq jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
arrives_in arr_seq jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 by apply H_jobs_come_from_arrival_sequence with x.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 rewrite /arrived_between; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 move: PRIO => /andP [PRIO1 PRIO2].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
              rewrite leqNgt; apply/negP; intros AB.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
              move: (Sched_jo).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 rewrite -[scheduled_at _ _ _]Bool.negb_involutive;
                                  move => /negP SCHED2; apply: SCHED2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
              apply completed_implies_not_scheduled; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 
              apply completion_monotonic with t1; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
              apply H_quiet_time; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
arrives_in arr_seq jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
              eapply H_jobs_come_from_arrival_sequence; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 by apply leq_ltn_trans with x; [apply H_jobs_must_arrive_to_execute | done].
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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 erewrite eq_bigr; last by move=> i _; rewrite service_at_def /=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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
          ideal_proc_model_sched_case_analysis_eq sched x jo; first by rewrite big1_eq.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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
          move: (Sched_jo); rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job i j)
   (Some jo == Some i) <= another_hep_job jo j
          destruct (another_hep_job jo j) eqn:PRIO.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false rewrite -EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false have SCH := service_of_jobs_le_1 _ _ sched _ (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false
            eapply leq_trans; last first.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false apply SCH; eauto using arrivals_uniq, ideal_proc_model_provides_unit_service,
                            ideal_proc_model_is_a_uniprocessor_model.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | another_hep_job i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | another_hep_job i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false rewrite /service_of_jobs_at; erewrite leq_sum => // i _.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
another_hep_job i j) 
(Some jo == Some i) <= false
              by rewrite service_at_def.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | another_hep_job i j)
   (Some jo == Some i) <= false rewrite leqn0 big1 //; intros joo PRIO2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
            apply/eqP; rewrite eqb0; apply/eqP; intros C.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
            inversion C; subst joo; clear C.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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. *) 
      Lemma instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_tasks:
        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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        rewrite /service_of_hep_jobs_from_other_tasks /service_of_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | hep_job_from_another_task
                                      j0 j)
   service_during sched j0 t1 t
        rewrite /cumulative_interference_from_hep_jobs_from_other_tasks
                /is_interference_from_hep_job_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 => hep_job_from_another_task jhp j
   | None => false
   end =
\sum_(j0 <- arrivals_between t1 t | hep_job_from_another_task
                                      j0 j)
   service_during sched j0 t1 t
        rewrite exchange_big //= big_nat_cond [in X in _ = X]big_nat_cond.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 => hep_job_from_another_task jhp j
   | None => false
   end =
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   \sum_(i0 <- arrivals_between t1 t | hep_job_from_another_task
                                         i0 j)
      service_at sched i0 i
        all: apply/eqP; rewrite eqn_leq; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 => hep_job_from_another_task jhp j
   | None => false
   end <=
\sum_(t1 <= i < t | (t1 <= i < t) && true)
   \sum_(i0 <- arrivals_between t1 t | hep_job_from_another_task
                                         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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
   hep_job_from_another_task i0 j)
      service_at sched i0 i <=
\sum_(t1 <= i < t | 
(t1 <= i < t) && true)
   match sched i with
   | Some jhp => hep_job_from_another_task jhp j
   | None => false
   end
        all: rewrite leq_sum //; move => x /andP [/andP [Ge Le] _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 => hep_job_from_another_task jhp j
| None => false
end <=
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | 
hep_job_from_another_task i j) 
service_at sched i x <=
match sched x with
| Some jhp => hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 => hep_job_from_another_task jhp j
| None => false
end <=
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   service_at sched i x ideal_proc_model_sched_case_analysis_eq sched x jo; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 => hep_job_from_another_task jhp j
| None => false
end <=
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   service_at sched i x
          move: (Sched_jo); rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
hep_job_from_another_task jo j <=
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   service_at sched i x
          destruct (hep_job_from_another_task jo j) eqn:PRIO; last 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
true <=
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   service_at sched i x
          rewrite (big_rem jo) /=; first by rewrite PRIO service_at_def EQ eq_refl.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
jo \in arrivals_between t1 t
          apply arrived_between_implies_in_arrivals; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
arrives_in arr_seq jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
arrives_in arr_seq jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
arrived_between jo t1 t by apply H_jobs_come_from_arrival_sequence with x.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
arrived_between jo t1 t rewrite /arrived_between; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t move: PRIO => /andP [PRIO1 PRIO2].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t
              rewrite leqNgt; apply/negP; intros AB.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t
              move: (Sched_jo).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t rewrite -[scheduled_at _ _ _]Bool.negb_involutive;
                                  move => /negP SCHED2; apply: SCHED2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t
              apply completed_implies_not_scheduled; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t 
              apply completion_monotonic with t1; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t
              apply H_quiet_time; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
arrives_in arr_seq jo
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t
              by eapply H_jobs_come_from_arrival_sequence; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
job_arrival jo < t by apply leq_ltn_trans with x; [apply H_jobs_must_arrive_to_execute | done].
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | hep_job_from_another_task
                                     i j)
   service_at sched i x <=
match sched x with
| Some jhp => hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | hep_job_from_another_task
                                     i j)
   service_at sched i x <=
match sched x with
| Some jhp => hep_job_from_another_task jhp j
| None => false
end erewrite eq_bigr; last by move=> i _; rewrite service_at_def /=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | hep_job_from_another_task
                                     i j)
   (fun i0 : Job => nat_of_bool (sched x == Some i0))
     i <=
match sched x with
| Some jhp => hep_job_from_another_task jhp j
| None => false
end
          ideal_proc_model_sched_case_analysis_eq sched x jo; first by rewrite big1_eq.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | hep_job_from_another_task
                                     i j)
   (sched x == Some i) <=
match sched x with
| Some jhp => hep_job_from_another_task jhp j
| None => false
end
          move: (Sched_jo); rewrite scheduled_at_def; move => /eqP EQ; rewrite EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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 t1 t | hep_job_from_another_task
                                     i j)
   (Some jo == Some i) <=
hep_job_from_another_task jo j
          destruct (hep_job_from_another_task jo j) eqn:PRIO.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task i j) 
(Some jo == Some i) <= false rewrite -EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task i j) 
(Some jo == Some i) <= false have SCH := service_of_jobs_le_1 _ _ sched _ (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task i j) 
(Some jo == Some i) <= false
            eapply leq_trans; last first.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task i j) 
(Some jo == Some i) <= false by apply SCH; eauto using arrivals_uniq, ideal_proc_model_provides_unit_service,
                            ideal_proc_model_is_a_uniprocessor_model.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between t1 t) x <= 1
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   (sched x == Some i) <=
service_of_jobs_at sched ?p (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task i j) 
(Some jo == Some i) <= false rewrite /service_of_jobs_at; erewrite leq_sum => // i _.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = true
SCH: unit_service_proc_model
  (ideal.processor_state Job) ->
uniprocessor_model (ideal.processor_state Job) ->
forall p : pred Job,
uniq (arrivals_between t1 t) ->
service_of_jobs_at sched p
  (arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | 
hep_job_from_another_task i j) 
(Some jo == Some i) <= false
              by rewrite service_at_def.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
\sum_(i <- arrivals_between t1 t | hep_job_from_another_task
                                     i j)
   (Some jo == Some i) <= false rewrite leqn0 big1 //; intros joo PRIO2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
joo: Job
PRIO2: hep_job_from_another_task joo j
(Some jo == Some joo) = 0
            apply/eqP; rewrite eqb0; apply/eqP; intros C.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
joo: Job
PRIO2: hep_job_from_another_task joo j
C: Some jo = Some joo
False
            inversion C; subst joo; clear C.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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: hep_job_from_another_task jo j = false
PRIO2: hep_job_from_another_task 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. *)
        
        Lemma quiet_time_cl_implies_quiet_time_ab:
          forall t, 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
          intros t QT; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t intros.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t
            have CIS := cumulative_interference_split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: 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
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t
            rewrite /cumulative_interference in CIS.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
cumul_interference interference j 0 t =
cumul_interfering_workload interfering_workload j 0 t
            rewrite /cumul_interference /cumul_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
\sum_(0 <= t < t) interference j t =
\sum_(0 <= t < t) interfering_workload j t
            rewrite CIS !big_split //=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
cumulative_priority_inversion j 0 t +
cumulative_interference_from_other_hep_jobs j 0 t =
\sum_(0 <= i < t) is_priority_inversion j i +
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i
            apply/eqP; rewrite eqn_add2l.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
cumulative_interference_from_other_hep_jobs j 0 t ==
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i
            rewrite instantiated_cumulative_interference_of_hep_jobs_equal_total_interference_of_hep_jobs;
              last by apply zero_is_quiet_time.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
service_of_other_hep_jobs j 0 t ==
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i
            have L2 := instantiated_cumulative_workload_of_hep_jobs_equal_total_workload_of_hep_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
L2: forall (t1 t2 : instant) (j : Job),
cumulative_interfering_workload_of_hep_jobs j t1
  t2 = workload_of_other_hep_jobs j t1 t2
service_of_other_hep_jobs j 0 t ==
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i
            rewrite /cumulative_interfering_workload_of_hep_jobs in L2; rewrite L2; clear L2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
service_of_other_hep_jobs j 0 t ==
workload_of_other_hep_jobs j 0 t
            rewrite eq_sym; apply/eqP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
workload_of_other_hep_jobs j 0 t =
service_of_other_hep_jobs j 0 t
            apply all_jobs_have_completed_equiv_workload_eq_service;
              eauto using ideal_proc_model_provides_unit_service.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
forall j0 : Job,
j0 \in arrival_sequence.arrivals_between arr_seq 0 t ->
another_hep_job j0 j -> completed_by sched j0 t
            intros j0 IN HEP; apply QT.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.arrivals_between arr_seq 0
        t
HEP: another_hep_job j0 j
arrived_before j0 t by apply in_arrivals_implies_arrived in IN.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.arrivals_between arr_seq 0
        t
HEP: another_hep_job j0 j
arrived_before j0 t by move: HEP => /andP [H6 H7].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
j0: Job
IN: j0
  \in arrival_sequence.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.
          }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
~~ pending_earlier_and_at sched j t rewrite negb_and Bool.negb_involutive; apply/orP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
~~ arrived_before j t \/ completed_by sched j t
            case ARR: (arrived_before j t); [right | by left].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
QT: quiet_time_cl j t
ARR: arrived_before j t = true
completed_by sched j t 
            apply QT; try eauto 2.
          }
        Qed.

        Lemma quiet_time_ab_implies_quiet_time_cl:
          forall t, 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
          have CIS := cumulative_interference_split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: 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
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t
          have IC1 := instantiated_cumulative_interference_of_hep_jobs_equal_total_interference_of_hep_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: 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
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t = service_of_other_hep_jobs j t1 t
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t
          rewrite /cumulative_interference /service_of_other_hep_jobs in CIS, IC1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
forall t : instant,
quiet_time_ab j t -> quiet_time_cl j t
          intros t [T0 T1]; intros jhp ARR HP ARB.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
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
          eapply all_jobs_have_completed_equiv_workload_eq_service with
              (P := fun jhp => hep_job jhp j) (t1 := 0) (t2 := t);
            eauto using arrived_between_implies_in_arrivals, ideal_proc_model_provides_unit_service.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
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)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t
          move: T0; rewrite /cumul_interference /cumul_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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
\sum_(0 <= t < t) interference j t =
\sum_(0 <= t < t) interfering_workload j t ->
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t
          rewrite CIS !big_split //=; move => /eqP; rewrite eqn_add2l.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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_interference_from_other_hep_jobs j 0 t ==
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i ->
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t
          rewrite IC1; last by apply zero_is_quiet_time.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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
service_of_jobs sched (another_hep_job^~ j)
  (arrivals_between 0 t) 0 t ==
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i ->
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t
          have L2 := instantiated_cumulative_workload_of_hep_jobs_equal_total_workload_of_hep_jobs;
                       rewrite /cumulative_interfering_workload_of_hep_jobs in L2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
service_of_jobs sched (another_hep_job^~ j)
  (arrivals_between 0 t) 0 t ==
\sum_(0 <= i < t) interfering_workload_of_hep_jobs j i ->
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t
          rewrite L2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
service_of_jobs sched (another_hep_job^~ j)
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t ->
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t move => T2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) =
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t apply/eqP; rewrite eq_sym.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
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
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t)
          move: T1; rewrite negb_and Bool.negb_involutive -leqNgt; move => /orP [T1 | T1].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) have NOTIN: j \notin arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
j \notin arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
NOTIN: j \notin arrivals_between 0 t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
j \notin arrivals_between 0 t apply/memPn; intros jo IN; apply/negP; intros EQ; move: EQ => /eqP EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
jo: Job
IN: jo \in arrivals_between 0 t
EQ: jo = j
False
              subst jo.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
IN: j \in arrivals_between 0 t
False
              apply in_arrivals_implies_arrived_between in IN; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
IN: arrived_between j 0 t
False
                by move: IN => /andP [_ IN]; move: T1; rewrite leqNgt; move => /negP LT; apply: LT. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: t <= job_arrival j
NOTIN: j \notin arrivals_between 0 t
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t)
            rewrite /workload_of_other_hep_jobs in T2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T1: t <= job_arrival j
NOTIN: j \notin arrivals_between 0 t
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_jobs 
  (another_hep_job^~ j) 
  (arrivals_between 0 t)
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t)
              by rewrite /service_of_jobs /workload_of_jobs !sum_notin_rem_eqn in T2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) have JIN: j \in arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
j \in arrivals_between 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
service_of_jobs sched 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs 
  (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
j \in arrivals_between 0 t eapply completed_implies_scheduled_before in T1; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: exists t' : nat,
  job_arrival j <= t' < t /\
  scheduled_at sched j t'
j \in arrivals_between 0 t
              apply arrived_between_implies_in_arrivals; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: exists t' : nat,
  job_arrival j <= t' < t /\
  scheduled_at sched j t'
arrived_between j 0 t
              move: T1 => [t' [T3 _]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
t': nat
T3: job_arrival j <= t' < t
arrived_between j 0 t
              apply/andP; split; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
t': nat
T3: job_arrival j <= t' < t
job_arrival j < t
              move: T3 => /andP [H3e H3t].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
t': nat
H3e: job_arrival j <= t'
H3t: t' < t
job_arrival j < t
                by apply leq_ltn_trans with t'. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t)
            have UNIC: uniq (arrivals_between 0 t) by eapply arrivals_uniq; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
service_of_jobs sched (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 0 t ==
workload_of_jobs (hep_job^~ j)
  (arrival_sequence.arrivals_between arr_seq 0 t) 
            unfold service_of_jobs, workload_of_jobs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
\sum_(j0 <- arrival_sequence.arrivals_between arr_seq
              0 t | hep_job j0 j)
   service_during sched j0 0 t ==
\sum_(j0 <- arrival_sequence.arrivals_between arr_seq
              0 t | hep_job j0 j) job_cost j0
            rewrite big_mkcond //= (bigD1_seq j) //= -big_mkcondl //=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T2: service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between 0 t) 0 t ==
workload_of_other_hep_jobs j 0 t
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
(if hep_job j j then service_during sched j 0 t else 0) +
\sum_(i <- arrival_sequence.arrivals_between arr_seq 0
             t | hep_job i j && (i != j))
   service_during sched i 0 t ==
\sum_(j0 <- arrival_sequence.arrivals_between arr_seq
              0 t | hep_job j0 j) job_cost j0
            move: T2; rewrite /service_of_jobs; move => /eqP T2; rewrite T2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
T2: \sum_(j0 <- 
arrivals_between 0 t | 
another_hep_job j0 j) 
service_during sched j0 0 t =
workload_of_other_hep_jobs j 0 t
(if hep_job j j then service_during sched j 0 t else 0) +
workload_of_other_hep_jobs j 0 t ==
\sum_(j0 <- arrival_sequence.arrivals_between arr_seq
              0 t | hep_job j0 j) job_cost j0
            rewrite [X in _ == X]big_mkcond //= [X in _ == X](bigD1_seq j) //= -big_mkcondl //=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
T2: \sum_(j0 <- 
arrivals_between 0 t | 
another_hep_job j0 j) 
service_during sched j0 0 t =
workload_of_other_hep_jobs j 0 t
(if hep_job j j then service_during sched j 0 t else 0) +
workload_of_other_hep_jobs j 0 t ==
(if hep_job j j then job_cost j else 0) +
\sum_(i <- arrival_sequence.arrivals_between arr_seq 0
             t | hep_job i j && (i != j)) job_cost i
            rewrite eqn_add2r; unfold 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
T2: \sum_(j0 <- 
arrivals_between 0 t | 
another_hep_job j0 j) 
service_during sched j0 0 t =
workload_of_other_hep_jobs j 0 t
(if H3 j j then service_during sched j 0 t else 0) ==
(if H3 j j then job_cost j else 0)
            erewrite H_priority_is_reflexive; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
T2: \sum_(j0 <- 
arrivals_between 0 t | 
another_hep_job j0 j) 
service_during sched j0 0 t =
workload_of_other_hep_jobs j 0 t
service_during sched j 0 t == job_cost j
            rewrite eqn_leq; apply/andP; split; try eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
CIS: forall (j : Job) (t1 t2 : instant),
\sum_(t1 <= t < t2) interference j t =
cumulative_priority_inversion j t1 t2 +
cumulative_interference_from_other_hep_jobs j t1
  t2
IC1: forall (j : Job) (t1 t : instant),
quiet_time_cl j t1 ->
cumulative_interference_from_other_hep_jobs j t1
  t =
service_of_jobs sched 
  (another_hep_job^~ j) 
  (arrivals_between t1 t) t1 t
t: instant
jhp: Job
ARR: arrives_in arr_seq jhp
HP: hep_job jhp j
ARB: arrived_before jhp t
L2: forall (t1 t2 : instant) (j : Job),
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs j t =
workload_of_other_hep_jobs j t1 t2
T1: completed_by sched j t
JIN: j \in arrivals_between 0 t
UNIC: uniq (arrivals_between 0 t)
T2: \sum_(j0 <- 
arrivals_between 0 t | 
another_hep_job j0 j) 
service_during sched j0 0 t =
workload_of_other_hep_jobs j 0 t
service_during sched j 0 t <= job_cost j
              by apply service_at_most_cost; rt_eauto.
        Qed.
 
        (** The equivalence trivially follows from the lemmas above. *)
        Corollary instantiated_quiet_time_equivalent_quiet_time:
          forall t,
            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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
          intros ?; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t: instant
quiet_time_ab j t -> quiet_time_cl j t apply quiet_time_cl_implies_quiet_time_ab.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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. *)
        Lemma instantiated_busy_interval_equivalent_busy_interval:
          forall t1 t2,
            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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
          split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t1, t2: instant
busy_interval_cl j t1 t2 -> busy_interval_ab j t1 t2 move => [[NEQ [QTt1 [NQT REL]] QTt2]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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
            split; [split; [ |split] | ].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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 done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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 apply instantiated_quiet_time_equivalent_quiet_time in QTt1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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 intros t NE QT; eapply NQT; eauto 2; apply instantiated_quiet_time_equivalent_quiet_time.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
t1, t2: instant
busy_interval_ab j t1 t2 -> busy_interval_cl j t1 t2 move => [[/andP [NEQ1 NEQ2] [QTt1 NQT] QTt2]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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
            split; [split; [ | split; [ |split] ] | ].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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 apply leq_ltn_trans with (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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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 intros t NEQ QT; eapply NQT; eauto 2; eapply instantiated_quiet_time_equivalent_quiet_time in QT; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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 apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between 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
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.
    Hypothesis H_work_conserving :  work_conserving arr_seq sched.

    (** 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. *)

    Let work_conservation_ab := definitions.work_conserving arr_seq sched interference interfering_workload.
    
    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. *)
    Lemma not_interference_implies_scheduled :
        ~ 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
      move => /negP HYP; move : HYP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
      rewrite negb_or !/is_priority_inversion
        /is_interference_from_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion sched j t &&
~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end -> scheduled_at sched j t
      move => /andP [HYP1 HYP2].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion sched
  j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
scheduled_at sched j t
      ideal_proc_model_sched_case_analysis_eq sched t jo.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion sched
  j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
Idle: ideal.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion sched
  j t
HYP2: ~~
match sched t with
| Some jhp => another_hep_job jhp j
| None => false
end
Idle: ideal.is_idle sched t
EqIdle: sched t = None
scheduled_at sched j t
        exfalso; clear HYP1 HYP2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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: ideal.is_idle sched t
EqIdle: sched t = None
False
        eapply instantiated_busy_interval_equivalent_busy_interval in H_busy_interval; 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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: ideal.is_idle sched t
EqIdle: sched t = None
False
        move: H_busy_interval => [PREF _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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: ideal.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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion 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
        clear EqSched_jo; move: Sched_jo; rewrite scheduled_at_def; move => /eqP 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion 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
        rewrite EqSched_jo in HYP1, HYP2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion sched
  j t
HYP2: ~~ another_hep_job jo j
scheduled_at sched j t
        move: HYP1 HYP2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
~~ priority_inversion.is_priority_inversion sched j t ->
~~ another_hep_job jo j -> scheduled_at sched j t
        rewrite / priority_inversion.is_priority_inversion 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
~~ ~~ hep_job jo j ->
~~ another_hep_job jo j -> scheduled_at sched j t
        move => /negPn HYP1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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: hep_job jo j
~~ another_hep_job jo j -> scheduled_at sched j t
        rewrite  negb_and.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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: hep_job jo j
~~ hep_job jo j || ~~ (jo != j) ->
scheduled_at sched j t
        move => /orP [/negP HYP2|/negPn /eqP HYP2]; first 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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: hep_job jo j
HYP2: jo = j
scheduled_at sched j t
        by rewrite -HYP2 scheduled_at_def EqSched_jo. }
    Qed.

    (** Conversely, if the job is scheduled at [t] then interference is [false]. *)
    Lemma scheduled_implies_no_interference :
      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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
      rewrite scheduled_at_def => /eqP HYP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
      apply /negP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
      rewrite /interference /is_priority_inversion
        /is_interference_from_another_hep_job
        HYP negb_or.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion sched j t &&
~~ another_hep_job j j
      apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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.is_priority_inversion 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 rewrite /priority_inversion.is_priority_inversion HYP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
        apply /negPn.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
        by apply (policy_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 rewrite  negb_and.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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]. *)
    Corollary instantiated_i_and_w_are_coherent_with_schedule :
      work_conservation_ab.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conservation_ab
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
work_conservation_ab
      move =>  j t1 t2 t ARR POS BUSY NEQ; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 (not_interference_implies_scheduled j ARR POS  t1 t2); try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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. *)
    Lemma instantiated_interference_and_workload_consistent_with_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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
interference_and_workload_consistent_with_sequential_tasks
  arr_seq sched tsk interference interfering_workload          
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
H_policy_respects_sequential_tasks: policy_respects_sequential_tasks
interference_and_workload_consistent_with_sequential_tasks
  arr_seq sched tsk interference interfering_workload
      move => j t1 t2 ARR /eqP TSK POS BUSY.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
  (arrival_sequence.arrivals_between arr_seq 0 t1) 0
  t1
      eapply instantiated_busy_interval_equivalent_busy_interval in BUSY; 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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
  (arrival_sequence.arrivals_between arr_seq 0 t1) 0
  t1
      eapply all_jobs_have_completed_equiv_workload_eq_service; 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_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.arrivals_between arr_seq 0 t1 ->
job_of_task tsk j -> completed_by sched j t1
      move => s INs /eqP TSKs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.arrivals_between arr_seq
        0 t1
TSKs: job_task s = tsk
completed_by sched s t1
      move: (INs) => NEQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.arrivals_between arr_seq
        0 t1
TSKs: job_task s = tsk
NEQ: s
  \in arrival_sequence.arrivals_between arr_seq
        0 t1
completed_by sched s t1 
      eapply in_arrivals_implies_arrived_between in NEQ; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.arrivals_between arr_seq
        0 t1
TSKs: job_task s = tsk
NEQ: arrived_between s 0 t1
completed_by sched s t1
      move: NEQ => /andP [_ JAs].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.arrivals_between arr_seq
        0 t1
TSKs: job_task s = tsk
JAs: job_arrival s < t1
completed_by sched s t1
      move: (BUSY) => [[ _ [QT [_ /andP [JAj _]]] _]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.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
      apply QT; try done; first by eapply in_arrivals_implies_arrived; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.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
      apply H_policy_respects_sequential_tasks; first by rewrite  TSK TSKs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
H1: JobArrival Job
H2: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute
  sched
H_completed_jobs_dont_execute: completed_jobs_dont_execute
  sched
H_sequential_tasks: sequential_tasks arr_seq sched
H3: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H_JLFP_respects_sequential_tasks: policy_respects_sequential_tasks
tsk: Task
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
arrivals_between:= arrival_sequence.arrivals_between
  arr_seq: instant -> instant -> seq Job
cumulative_task_interference:= cumul_task_interference
  arr_seq sched: (Job -> instant -> bool) ->
Task ->
instant ->
nat -> nat -> nat
another_hep_job:= fun j1 j2 : Job =>
hep_job j1 j2 && (j1 != j2): JLFP_policy Job
hep_job_from_another_task:= fun j1 j2 : Job =>
hep_job j1 j2 &&
(job_task j1 != job_task j2): JLFP_policy Job
is_priority_inversion:= fun j : Job =>
[eta priority_inversion.is_priority_inversion
       sched j]: Job -> instant -> bool
cumulative_interference_from_other_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   is_interference_from_another_hep_job
     j t: Job ->
instant ->
instant -> nat
cumulative_interference:= fun (j : Job)
  (t1 t2 : instant) =>
\sum_(t1 <= t < t2)
   interference j t: Job ->
instant -> instant -> nat
cumulative_interfering_workload_of_hep_jobs:= fun (j : Job)
  (t1
   t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload_of_hep_jobs
     j t: Job ->
instant ->
instant -> nat
cumulative_interfering_workload:= fun (j : Job)
  (t1 t2 : instant)
=>
\sum_(t1 <= t < t2)
   interfering_workload
     j t: Job ->
instant ->
instant -> nat
quiet_time_cl:= quiet_time arr_seq sched: Job -> instant -> Prop
quiet_time_ab:= definitions.quiet_time sched
  interference interfering_workload: Job -> instant -> Prop
busy_interval_cl:= busy_interval arr_seq sched: Job -> instant -> instant -> Prop
busy_interval_ab:= definitions.busy_interval sched
  interference interfering_workload: Job -> instant -> instant -> Prop
workload_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
workload_of_jobs
  (another_hep_job^~ j)
  (arrivals_between t1 t2): Job ->
instant -> instant -> nat
service_of_hep_jobs_from_other_tasks:= fun (j : Job)
  (t1
   t2 : instant)
=>
service_of_jobs
  sched
  (hep_job_from_another_task^~ j)
  (arrivals_between
     t1 t2) t1 t2: Job ->
instant ->
instant -> nat
service_of_other_hep_jobs:= fun (j : Job)
  (t1 t2 : instant) =>
service_of_jobs sched
  (another_hep_job^~ j)
  (arrivals_between t1 t2)
  t1 t2: Job ->
instant -> instant -> nat
H4: JobReady Job (ideal.processor_state Job)
H_work_bearing_readiness: work_bearing_readiness
  arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_work_conserving: work_conserving arr_seq sched
policy_reflexive: reflexive_priorities
work_conservation_ab:= definitions.work_conserving
  arr_seq sched interference
  interfering_workload: Prop
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 arrival_sequence.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.
    
  End I_IW_correctness.

End JLFPInstantiation.