Library prosa.results.edf.rta.bounded_pi


(* ----------------------------------[ coqtop ]---------------------------------

Welcome to Coq 8.11.2 (June 2020)

----------------------------------------------------------------------------- *)


Require Export prosa.analysis.facts.edf.
Require Export prosa.model.schedule.priority_driven.
Require Export prosa.analysis.facts.busy_interval.carry_in.
Require Export prosa.analysis.definitions.schedulability.
Require Import prosa.model.priority.edf.
Require Import prosa.model.task.absolute_deadline.
Require Import prosa.analysis.abstract.ideal_jlfp_rta.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.

Throughout this file, we assume ideal uni-processor schedules.
Require Import prosa.model.processor.ideal.

Throughout this file, we assume the basic (i.e., Liu & Layland) readiness model.
Require Import prosa.model.readiness.basic.

Abstract RTA for EDF-schedulers with Bounded Priority Inversion

In this module we instantiate the Abstract Response-Time analysis (aRTA) to EDF-schedulers for ideal uni-processor model of real-time tasks with arbitrary arrival models.
Given EDF priority policy and an ideal uni-processor scheduler model, we can explicitly specify [interference], [interfering_workload], and [interference_bound_function]. In this settings, we can define natural notions of service, workload, busy interval, etc. The important feature of this instantiation is that we can induce the meaningful notion of priority inversion. However, we do not specify the exact cause of priority inversion (as there may be different reasons for this, like execution of a non-preemptive segment or blocking due to resource locking). We only assume that that a priority inversion is bounded.
Consider any type of tasks ...
  Context {Task : TaskType}.
  Context `{TaskCost Task}.
  Context `{TaskDeadline Task}.
  Context `{TaskRunToCompletionThreshold Task}.

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

For clarity, let's denote the relative deadline of a task as D.
  Let D tsk := task_deadline tsk.

Consider the EDF policy that indicates a higher-or-equal priority relation. Note that we do not relate the EDF policy with the scheduler. However, we define functions for Interference and Interfering Workload that actively use the concept of priorities.
  Let EDF := EDF Job.

Consider any arrival sequence with consistent, non-duplicate arrivals.
Next, consider any ideal uniprocessor schedule of this arrival sequence ...
... where jobs do not execute before their arrival or after completion.
Note that we differentiate between abstract and classical notions of work conserving schedule.
We assume that the schedule is a work-conserving schedule in the _classical_ sense, and later prove that the hypothesis about abstract work-conservation also holds.
Assume we have sequential tasks, i.e, jobs from the same task execute in the order of their arrival.
Assume that a job cost cannot be larger than a task cost.
Consider an arbitrary task set ts.
  Variable ts : list Task.

Next, we assume that all jobs come from the task set.
Let max_arrivals be a family of valid arrival curves, i.e., for any task [tsk] in ts [max_arrival tsk] is (1) an arrival bound of [tsk], and (2) it is a monotonic function that equals 0 for the empty interval delta = 0.
Let [tsk] be any task in ts that is to be analyzed.
  Variable tsk : Task.
  Hypothesis H_tsk_in_ts : tsk \in ts.

Consider a valid preemption model...
...and a valid task run-to-completion threshold function. That is, [task_run_to_completion_threshold tsk] is (1) no bigger than [tsk]'s cost, (2) for any job of task [tsk] job_run_to_completion_threshold is bounded by task_run_to_completion_threshold.
We introduce [rbf] as an abbreviation of the task request bound function, which is defined as [task_cost(T) × max_arrivals(T,Δ)] for some task T.
Next, we introduce [task_rbf] as an abbreviation of the task request bound function of task [tsk].
  Let task_rbf := rbf tsk.

Using the sum of individual request bound functions, we define the request bound function of all tasks (total request bound function).
For simplicity, let's define some local names.
Assume that there exists a constant priority_inversion_bound that bounds the length of any priority inversion experienced by any job of [tsk]. Since we analyze only task [tsk], we ignore the lengths of priority inversions incurred by any other tasks.
Let L be any positive fixed point of the busy interval recurrence.
  Variable L : duration.
  Hypothesis H_L_positive : L > 0.
  Hypothesis H_fixed_point : L = total_rbf L.

Next, we define an upper bound on interfering workload received from jobs of other tasks with higher-than-or-equal priority.
  Let bound_on_total_hep_workload (A Δ : duration) :=
    \sum_(tsk_o <- ts | tsk_o != tsk)
     rbf tsk_o (minn ((A + ε) + D tsk - D tsk_o) Δ).

To reduce the time complexity of the analysis, we introduce the notion of search space for EDF. Intuitively, this corresponds to all "interesting" arrival offsets that the job under analysis might have with regard to the beginning of its busy-window.
In case of search space for EDF we ask whether [task_rbf A ≠ task_rbf (A + ε)]...
  Definition task_rbf_changes_at (A : duration) := task_rbf A != task_rbf (A + ε).

...or there exists a task [tsko] from ts such that [tsko ≠ tsk] and [rbf(tsko, A + D tsk - D tsko) ≠ rbf(tsko, A + ε + D tsk - D tsko)]. Note that we use a slightly uncommon notation [has (λ tsko ⇒ P tskₒ) ts] which can be interpreted as follows: task-set ts contains a task [tsko] such that a predicate [P] holds for [tsko].
  Definition bound_on_total_hep_workload_changes_at A :=
    has (fun tsko
           (tsk != tsko)
             && (rbf tsko (A + D tsk - D tsko)
                     != rbf tsko ((A + ε) + D tsk - D tsko))) ts.

The final search space for EDF is a set of offsets that are less than [L] and where [task_rbf] or [bound_on_total_hep_workload] changes.
Let R be a value that upper-bounds the solution of each response-time recurrence, i.e., for any relative arrival time A in the search space, there exists a corresponding solution F such that [F + (task cost - task lock-in service) <= R].
  Variable R : duration.
  Hypothesis H_R_is_maximum:
     (A : duration),
      is_in_search_space A
       (F : duration),
        A + F = priority_inversion_bound
                + (task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk))
                + bound_on_total_hep_workload A (A + F)
        F + (task_cost tsk - task_run_to_completion_threshold tsk) R.


To use the theorem uniprocessor_response_time_bound_seq from the Abstract RTA module, we need to specify functions of interference, interfering workload and IBF.
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.
  Let interference (j : Job) (t : instant) :=
    ideal_jlfp_rta.interference sched 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.
Finally, we define the interference bound function as the sum of the priority interference bound and the higher-or-equal-priority workload.

Filling Out Hypothesis Of Abstract RTA Theorem

In this section we prove that all hypotheses necessary to use the abstract theorem are satisfied.
First, we prove that in the instantiation of interference and interfering workload, we really take into account everything that can interfere with [tsk]'s jobs, and thus, the scheduler satisfies the abstract notion of work conserving schedule.
    Lemma instantiated_i_and_w_are_coherent_with_schedule:
      work_conserving_ab tsk interference interfering_workload.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2519)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  work_conserving_ab tsk interference interfering_workload

----------------------------------------------------------------------------- *)


    Proof.
      unfold EDF in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2521)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  work_conserving_ab tsk interference interfering_workload

----------------------------------------------------------------------------- *)


      intros j t1 t2 t ARR TSK POS BUSY NEQ; split; intros HYP;
        [move: HYP ⇒ /negP | rewrite scheduled_at_def in HYP; move: HYP ⇒ /eqP HYP ].

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2582)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  ============================
  ~~ interference j t -> scheduled_at sched j t

subgoal 2 (ID 2690) is:
 ~ interference j t

----------------------------------------------------------------------------- *)


      {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2582)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  ============================
  ~~ interference j t -> scheduled_at sched j t

----------------------------------------------------------------------------- *)


rewrite negb_or /is_priority_inversion /is_priority_inversion
                /is_interference_from_another_hep_job.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2703)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  ============================
  ~~ 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 -> scheduled_at sched j t

----------------------------------------------------------------------------- *)


        move ⇒ /andP [HYP1 HYP2].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2743)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP1 : ~~
         match sched t with
         | Some jlp => ~~ hep_job jlp j
         | None => false
         end
  HYP2 : ~~
         match sched t with
         | Some jhp => hep_job jhp j && (jhp != j)
         | None => false
         end
  ============================
  scheduled_at sched j t

----------------------------------------------------------------------------- *)


        ideal_proc_model_sched_case_analysis_eq sched t jo.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2791)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP1 : ~~
         match sched t with
         | Some jlp => ~~ hep_job jlp j
         | None => false
         end
  HYP2 : ~~
         match sched t with
         | Some jhp => hep_job jhp j && (jhp != j)
         | None => false
         end
  Idle : is_idle sched t
  EqIdle : sched t = None
  ============================
  scheduled_at sched j t

subgoal 2 (ID 2837) is:
 scheduled_at sched j t

----------------------------------------------------------------------------- *)


        {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2791)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP1 : ~~
         match sched t with
         | Some jlp => ~~ hep_job jlp j
         | None => false
         end
  HYP2 : ~~
         match sched t with
         | Some jhp => hep_job jhp j && (jhp != j)
         | None => false
         end
  Idle : is_idle sched t
  EqIdle : sched t = None
  ============================
  scheduled_at sched j t

----------------------------------------------------------------------------- *)


exfalso; clear HYP1 HYP2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2840)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  Idle : is_idle sched t
  EqIdle : sched t = None
  ============================
  False

----------------------------------------------------------------------------- *)


          eapply instantiated_busy_interval_equivalent_edf_busy_interval in BUSY; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2850)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  NEQ : t1 <= t < t2
  Idle : is_idle sched t
  EqIdle : sched t = None
  ============================
  False

----------------------------------------------------------------------------- *)


          move: BUSY ⇒ [PREF _].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2880)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  NEQ : t1 <= t < t2
  Idle : is_idle sched t
  EqIdle : sched t = None
  PREF : busy_interval.busy_interval_prefix arr_seq sched j t1 t2
  ============================
  False

----------------------------------------------------------------------------- *)


            by eapply not_quiet_implies_not_idle; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2837)

subgoal 1 (ID 2837) is:
 scheduled_at sched j t
subgoal 2 (ID 2690) is:
 ~ interference j t

----------------------------------------------------------------------------- *)


        }

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2837)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP1 : ~~
         match sched t with
         | Some jlp => ~~ hep_job jlp j
         | None => false
         end
  HYP2 : ~~
         match sched t with
         | Some jhp => hep_job jhp j && (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

----------------------------------------------------------------------------- *)


        {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2837)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP1 : ~~
         match sched t with
         | Some jlp => ~~ hep_job jlp j
         | None => false
         end
  HYP2 : ~~
         match sched t with
         | Some jhp => hep_job jhp j && (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.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2956)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP1 : ~~
         match sched t with
         | Some jlp => ~~ hep_job jlp j
         | None => false
         end
  HYP2 : ~~
         match sched t with
         | Some jhp => hep_job jhp j && (jhp != j)
         | None => false
         end
  jo : Job
  EqSched_jo : sched t = Some jo
  ============================
  scheduled_at sched j t

----------------------------------------------------------------------------- *)


          rewrite EqSched_jo in HYP1, HYP2.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3027)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  jo : Job
  EqSched_jo : sched t = Some jo
  HYP1 : ~~ ~~ hep_job jo j
  HYP2 : ~~ (hep_job jo j && (jo != j))
  ============================
  scheduled_at sched j t

----------------------------------------------------------------------------- *)


          move: HYP1 HYP2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3031)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  jo : Job
  EqSched_jo : sched t = Some jo
  ============================
  ~~ ~~ hep_job jo j ->
  ~~ (hep_job jo j && (jo != j)) -> scheduled_at sched j t

----------------------------------------------------------------------------- *)


          rewrite Bool.negb_involutive negb_and.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3038)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  jo : Job
  EqSched_jo : sched t = Some jo
  ============================
  hep_job jo j -> ~~ hep_job jo j || ~~ (jo != j) -> scheduled_at sched j t

----------------------------------------------------------------------------- *)


          moveHYP1 /orP [/negP HYP2| /eqP HYP2].

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3163)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  jo : Job
  EqSched_jo : sched t = Some jo
  HYP1 : hep_job jo j
  HYP2 : ~ hep_job jo j
  ============================
  scheduled_at sched j t

subgoal 2 (ID 3164) is:
 scheduled_at sched j t

----------------------------------------------------------------------------- *)


          - by exfalso.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3164)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  jo : Job
  EqSched_jo : sched t = Some jo
  HYP1 : hep_job jo j
  HYP2 : ~~ (jo != j) == true
  ============================
  scheduled_at sched j t

----------------------------------------------------------------------------- *)


          - rewrite Bool.negb_involutive in HYP2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3261)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  jo : Job
  EqSched_jo : sched t = Some jo
  HYP1 : hep_job jo j
  HYP2 : (jo == j) == true
  ============================
  scheduled_at sched j t

----------------------------------------------------------------------------- *)


            move: HYP2 ⇒ /eqP /eqP HYP2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3323)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : 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 subst jo; rewrite scheduled_at_def EqSched_jo.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2690)

subgoal 1 (ID 2690) is:
 ~ interference j t

----------------------------------------------------------------------------- *)


        }

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2690)

subgoal 1 (ID 2690) is:
 ~ interference j t

----------------------------------------------------------------------------- *)


      }

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2690)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP : sched t = Some j
  ============================
  ~ interference j t

----------------------------------------------------------------------------- *)


      {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2690)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP : sched t = Some j
  ============================
  ~ interference j t

----------------------------------------------------------------------------- *)


apply/negP;
          rewrite /interference /ideal_jlfp_rta.interference /is_priority_inversion
                  /is_interference_from_another_hep_job
                  HYP negb_or; apply/andP; split.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3424)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP : sched t = Some j
  ============================
  ~~ ~~ hep_job j j

subgoal 2 (ID 3425) is:
 ~~ (hep_job j j && (j != j))

----------------------------------------------------------------------------- *)


        - by rewrite Bool.negb_involutive; eapply (EDF_is_reflexive 0).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3425)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  t : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  NEQ : t1 <= t < t2
  HYP : sched t = Some j
  ============================
  ~~ (hep_job j j && (j != j))

----------------------------------------------------------------------------- *)


        - by rewrite negb_and Bool.negb_involutive; apply/orP; right.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


      }

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


    Qed.

Next, we prove that the interference and interfering workload functions 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.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2525)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  interference_and_workload_consistent_with_sequential_tasks arr_seq sched
    tsk interference interfering_workload

----------------------------------------------------------------------------- *)



    Proof.
      unfold EDF in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2527)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  interference_and_workload_consistent_with_sequential_tasks arr_seq sched
    tsk interference interfering_workload

----------------------------------------------------------------------------- *)


      intros j t1 t2 ARR TSK POS BUSY.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2535)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  ============================
  task_workload_between arr_seq tsk 0 t1 =
  task_service_of_jobs_in sched tsk (arrivals_between arr_seq 0 t1) 0 t1

----------------------------------------------------------------------------- *)


      eapply instantiated_busy_interval_equivalent_edf_busy_interval in BUSY; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2545)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  ============================
  task_workload_between arr_seq tsk 0 t1 =
  task_service_of_jobs_in sched tsk (arrivals_between arr_seq 0 t1) 0 t1

----------------------------------------------------------------------------- *)


      eapply all_jobs_have_completed_equiv_workload_eq_service; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2595)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  ============================
  forall j0 : Job,
  j0 \in arrivals_between arr_seq 0 t1 ->
  job_of_task tsk j0 -> completed_by sched j0 t1

----------------------------------------------------------------------------- *)


      intros s INs TSKs.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2643)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  INs : s \in arrivals_between arr_seq 0 t1
  TSKs : job_of_task tsk s
  ============================
  completed_by sched s t1

----------------------------------------------------------------------------- *)


      rewrite /arrivals_between in INs.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2711)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  ============================
  completed_by sched s t1

----------------------------------------------------------------------------- *)


      move: (INs) ⇒ NEQ.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2713)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs, NEQ : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  ============================
  completed_by sched s t1

----------------------------------------------------------------------------- *)


      eapply in_arrivals_implies_arrived_between in NEQ; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2716)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  NEQ : arrived_between s 0 t1
  ============================
  completed_by sched s t1

----------------------------------------------------------------------------- *)


      move: NEQ ⇒ /andP [_ JAs].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2775)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  JAs : job_arrival s < t1
  ============================
  completed_by sched s t1

----------------------------------------------------------------------------- *)


      move: (BUSY) ⇒ [[ _ [QT [_ /andP [JAj _]]] _]].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2856)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  JAs : job_arrival s < t1
  QT : busy_interval.quiet_time arr_seq sched j t1
  JAj : t1 <= job_arrival j
  ============================
  completed_by sched s t1

----------------------------------------------------------------------------- *)


      apply QT; try done.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2857)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  JAs : job_arrival s < t1
  QT : busy_interval.quiet_time arr_seq sched j t1
  JAj : t1 <= job_arrival j
  ============================
  arrives_in arr_seq s

subgoal 2 (ID 2858) is:
 hep_job s j

----------------------------------------------------------------------------- *)


      - eapply in_arrivals_implies_arrived; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2858)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  TSKs : job_of_task tsk s
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  JAs : job_arrival s < t1
  QT : busy_interval.quiet_time arr_seq sched j t1
  JAj : t1 <= job_arrival j
  ============================
  hep_job s j

----------------------------------------------------------------------------- *)


      - unfold edf.EDF, EDF; move: TSKs ⇒ /eqP TSKs.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2952)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  JAs : job_arrival s < t1
  QT : busy_interval.quiet_time arr_seq sched j t1
  JAj : t1 <= job_arrival j
  TSKs : job_task s = tsk
  ============================
  hep_job s j

----------------------------------------------------------------------------- *)


        rewrite /job_deadline /job_deadline_from_task_deadline /hep_job TSK TSKs leq_add2r.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2972)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  t1, t2 : instant
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
  s : Job
  INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
  JAs : job_arrival s < t1
  QT : busy_interval.quiet_time arr_seq sched j t1
  JAj : t1 <= job_arrival j
  TSKs : job_task s = tsk
  ============================
  job_arrival s <= job_arrival j

----------------------------------------------------------------------------- *)


          by apply leq_trans with t1; [apply ltnW | ].

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


    Qed.

Recall that L is assumed to be a fixed point of the busy interval recurrence. Thanks to this fact, we can prove that every busy interval (according to the concrete definition) is bounded. In addition, we know that the conventional concept of busy interval and the one obtained from the abstract definition (with the interference and interfering workload) coincide. Thus, it follows that any busy interval (in the abstract sense) is bounded.
    Lemma instantiated_busy_intervals_are_bounded:
      busy_intervals_are_bounded_by arr_seq sched tsk interference interfering_workload L.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2533)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  busy_intervals_are_bounded_by arr_seq sched tsk interference
    interfering_workload L

----------------------------------------------------------------------------- *)


    Proof.
      unfold EDF in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2535)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  busy_intervals_are_bounded_by arr_seq sched tsk interference
    interfering_workload L

----------------------------------------------------------------------------- *)


      intros j ARR TSK POS.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2540)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  ============================
  exists t1 t2 : nat,
    t1 <= job_arrival j < t2 /\
    t2 <= t1 + L /\
    busy_interval sched interference interfering_workload j t1 t2

----------------------------------------------------------------------------- *)


      edestruct exists_busy_interval_from_total_workload_bound
        with (Δ := L) as [t1 [t2 [T1 [T2 GGG]]]]; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2570)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  ============================
  forall t : instant,
  workload_of_jobs predT (arrivals_between arr_seq t (t + L)) <= L

subgoal 2 (ID 2591) is:
 exists t0 t3 : nat,
   t0 <= job_arrival j < t3 /\
   t3 <= t0 + L /\
   busy_interval sched interference interfering_workload j t0 t3

----------------------------------------------------------------------------- *)


      {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2570)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  ============================
  forall t : instant,
  workload_of_jobs predT (arrivals_between arr_seq t (t + L)) <= L

----------------------------------------------------------------------------- *)


by intros; rewrite {2}H_fixed_point; apply total_workload_le_total_rbf''.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2591)

subgoal 1 (ID 2591) is:
 exists t0 t3 : nat,
   t0 <= job_arrival j < t3 /\
   t3 <= t0 + L /\
   busy_interval sched interference interfering_workload j t0 t3

----------------------------------------------------------------------------- *)


}

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2591)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  t1, t2 : nat
  T1 : t1 <= job_arrival j < t2
  T2 : t2 <= t1 + L
  GGG : busy_interval.busy_interval arr_seq sched j t1 t2
  ============================
  exists t0 t3 : nat,
    t0 <= job_arrival j < t3 /\
    t3 <= t0 + L /\
    busy_interval sched interference interfering_workload j t0 t3

----------------------------------------------------------------------------- *)


       t1, t2; split; first by done.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2648)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  t1, t2 : nat
  T1 : t1 <= job_arrival j < t2
  T2 : t2 <= t1 + L
  GGG : busy_interval.busy_interval arr_seq sched j t1 t2
  ============================
  t2 <= t1 + L /\
  busy_interval sched interference interfering_workload j t1 t2

----------------------------------------------------------------------------- *)


      split; first by done.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2651)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  POS : 0 < job_cost j
  t1, t2 : nat
  T1 : t1 <= job_arrival j < t2
  T2 : t2 <= t1 + L
  GGG : busy_interval.busy_interval arr_seq sched j t1 t2
  ============================
  busy_interval sched interference interfering_workload j t1 t2

----------------------------------------------------------------------------- *)


        by eapply instantiated_busy_interval_equivalent_edf_busy_interval; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


    Qed.

Next, we prove that IBF is indeed an interference bound.
We show that task_interference_is_bounded_by is bounded by IBF by constructing a sequence of inequalities.
      Section Inequalities.

        (* Consider an arbitrary job j of [tsk]. *)
        Variable j : Job.
        Hypothesis H_j_arrives : arrives_in arr_seq j.
        Hypothesis H_job_of_tsk : job_task j = tsk.
        Hypothesis H_job_cost_positive: job_cost_positive j.

Consider any busy interval [t1, t2) of job [j].
        Variable t1 t2 : duration.
        Hypothesis H_busy_interval :
          definitions.busy_interval sched interference interfering_workload j t1 t2.

Let's define A as a relative arrival time of job j (with respect to time t1).
        Let A := job_arrival j - t1.

Consider an arbitrary shift Δ inside the busy interval ...
        Variable Δ : duration.
        Hypothesis H_Δ_in_busy : t1 + Δ < t2.

... and the set of all arrivals between [t1] and [t1 + Δ].
        Let jobs := arrivals_between arr_seq t1 (t1 + Δ).

Next, we define two predicates on jobs by extending EDF-priority relation.
Predicate [EDF_from tsk] holds true for any job [jo] of task [tsk] such that [job_deadline jo <= job_deadline j].
        Let EDF_from (tsk : Task) := fun (jo : Job) ⇒ EDF jo j && (job_task jo == tsk).

Predicate [EDF_not_from tsk] holds true for any job [jo] such that [job_deadline jo <= job_deadline j] and [job_task jo ≠ tsk].
        Let EDF_not_from (tsk : Task) := fun (jo : Job) ⇒ EDF jo j && (job_task jo != tsk).

Recall that [IBF(A, R) := priority_inversion_bound + bound_on_total_hep_workload(A, R)]. The fact that [priority_inversion_bound] bounds cumulative priority inversion follows from assumption [H_priority_inversion_is_bounded].
        Lemma cumulative_priority_inversion_is_bounded:
          cumulative_priority_inversion sched j t1 (t1 + Δ) priority_inversion_bound.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2565)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  ============================
  cumulative_priority_inversion sched j t1 (t1 + Δ) <=
  priority_inversion_bound

----------------------------------------------------------------------------- *)


        Proof.
          unfold priority_inversion_is_bounded_by, EDF in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2567)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  cumulative_priority_inversion sched j t1 (t1 + Δ) <=
  priority_inversion_bound

----------------------------------------------------------------------------- *)


          apply leq_trans with (cumulative_priority_inversion sched j t1 t2).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2575)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  cumulative_priority_inversion sched j t1 (t1 + Δ) <=
  cumulative_priority_inversion sched j t1 t2

subgoal 2 (ID 2576) is:
 cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound

----------------------------------------------------------------------------- *)


          - rewrite [X in _ X](@big_cat_nat _ _ _ (t1 + Δ)) //=.

(* ----------------------------------[ coqtop ]---------------------------------

4 subgoals (ID 2604)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  cumulative_priority_inversion sched j t1 (t1 + Δ) <=
  \sum_(t1 <= i < t1 + Δ) is_priority_inversion sched j i +
  \sum_(t1 + Δ <= i < t2) is_priority_inversion sched j i

subgoal 2 (ID 2627) is:
 t1 <= t1 + Δ
subgoal 3 (ID 2650) is:
 t1 + Δ <= t2
subgoal 4 (ID 2576) is:
 cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound

----------------------------------------------------------------------------- *)


            + by rewrite leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 2627)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  t1 <= t1 + Δ

subgoal 2 (ID 2650) is:
 t1 + Δ <= t2
subgoal 3 (ID 2576) is:
 cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound

----------------------------------------------------------------------------- *)


            + by rewrite /is_priority_inversion leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2650)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  t1 + Δ <= t2

subgoal 2 (ID 2576) is:
 cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound

----------------------------------------------------------------------------- *)


            + by rewrite ltnW.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2576)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound

----------------------------------------------------------------------------- *)


          - apply H_priority_inversion_is_bounded; try done.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2693)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  busy_interval.busy_interval_prefix arr_seq sched j t1 t2

----------------------------------------------------------------------------- *)


            eapply instantiated_busy_interval_equivalent_edf_busy_interval in H_busy_interval; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2886)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : forall j : Job,
                                    arrives_in arr_seq j ->
                                    job_task j = tsk ->
                                    0 < job_cost j ->
                                    priority_inversion_of_job_is_bounded_by
                                      arr_seq sched j
                                      priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval.busy_interval arr_seq sched j t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) =>
              edf.EDF Job jo j && (job_task jo == tsk) : 
  Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  edf.EDF Job jo j && (job_task jo != tsk)
   : Task -> Job -> bool
  ============================
  busy_interval.busy_interval_prefix arr_seq sched j t1 t2

----------------------------------------------------------------------------- *)


              by move: H_busy_interval ⇒ [PREF _].

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


        Qed.

Next, we show that [bound_on_total_hep_workload(A, R)] bounds interference from jobs with higher-or-equal priority.
From lemma [instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_tasks] it follows that cumulative interference from jobs with higher-or-equal priority from other tasks is equal to the total service of jobs with higher-or-equal priority from other tasks. Which in turn means that cumulative interference is bounded by service.
        Lemma cumulative_interference_is_bounded_by_total_service:
          cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ)
           service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2578)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  ============================
  cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ) <=
  service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)

----------------------------------------------------------------------------- *)


        Proof.
          move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2649)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ) <=
  service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)

----------------------------------------------------------------------------- *)


          erewrite instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_tasks;
            eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2656)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  service_of_jobs sched
    (fun jhp : Job => hep_job jhp j && (job_task jhp != job_task j))
    (arrivals_between arr_seq t1 (t1 + Δ)) t1 (t1 + Δ) <=
  service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)

subgoal 2 (ID 2662) is:
 busy_interval.quiet_time arr_seq sched j t1

----------------------------------------------------------------------------- *)


          - by rewrite -H_job_of_tsk /jobs.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2662)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  busy_interval.quiet_time arr_seq sched j t1

----------------------------------------------------------------------------- *)


          - rewrite /edf.EDF /EDF instantiated_quiet_time_equivalent_quiet_time //.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2770)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  reflexive_priorities

subgoal 2 (ID 2771) is:
 policy_respects_sequential_tasks

----------------------------------------------------------------------------- *)


            + by apply EDF_is_reflexive.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2771)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  policy_respects_sequential_tasks

----------------------------------------------------------------------------- *)


            + by apply EDF_respects_sequential_tasks.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


        Qed.

By lemma [service_of_jobs_le_workload], the total _service_ of jobs with higher-or-equal priority from other tasks is at most the total _workload_ of jobs with higher-or-equal priority from other tasks.
        Lemma total_service_is_bounded_by_total_workload:
          service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
           workload_of_jobs (EDF_not_from tsk) jobs.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2584)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  ============================
  service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ) <=
  workload_of_jobs (EDF_not_from tsk) jobs

----------------------------------------------------------------------------- *)


        Proof.
            by apply service_of_jobs_le_workload; eauto 2 with basic_facts.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


        Qed.

Next, we reorder summation. So the total workload of jobs with higher-or-equal priority from other tasks is equal to the sum over all tasks [tsk_o] that are to equal to task [tsk] of workload of jobs with higher-or-equal priority task [tsk_o].
        Lemma reorder_summation:
          workload_of_jobs (EDF_not_from tsk) jobs
           \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2595)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  ============================
  workload_of_jobs (EDF_not_from tsk) jobs <=
  \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs

----------------------------------------------------------------------------- *)


        Proof.
          unfold EDF_from.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2597)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  ============================
  workload_of_jobs (EDF_not_from tsk) jobs <=
  \sum_(tsk_o <- ts | tsk_o != tsk)
     workload_of_jobs (fun jo : Job => EDF jo j && (job_task jo == tsk_o))
       jobs

----------------------------------------------------------------------------- *)


          move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2668)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  workload_of_jobs (EDF_not_from tsk) jobs <=
  \sum_(tsk_o <- ts | tsk_o != tsk)
     workload_of_jobs (fun jo : Job => EDF jo j && (job_task jo == tsk_o))
       jobs

----------------------------------------------------------------------------- *)


          intros.
          rewrite (exchange_big_dep (EDF_not_from tsk)) //=.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2692)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  workload_of_jobs (EDF_not_from tsk) jobs <=
  \sum_(j0 <- jobs | EDF_not_from tsk j0)
     \sum_(i <- ts | [&& i != tsk, EDF j0 j & job_task j0 == i]) job_cost j0

subgoal 2 (ID 2715) is:
 forall (i : Task) (j0 : Job),
 i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0

----------------------------------------------------------------------------- *)


          - rewrite /workload_of_jobs big_seq_cond [X in _ X]big_seq_cond.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2773)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(i <- jobs | (i \in jobs) && EDF_not_from tsk i) job_cost i <=
  \sum_(i <- jobs | (i \in jobs) && EDF_not_from tsk i)
     \sum_(i0 <- ts | [&& i0 != tsk, EDF i j & job_task i == i0]) job_cost i

subgoal 2 (ID 2715) is:
 forall (i : Task) (j0 : Job),
 i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0

----------------------------------------------------------------------------- *)


            apply leq_sum; movejo /andP [ARRo /andP [HEQ TSKo]].

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2853)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  ARRo : jo \in jobs
  HEQ : EDF jo j
  TSKo : job_task jo != tsk
  ============================
  job_cost jo <=
  \sum_(i <- ts | [&& i != tsk, EDF jo j & job_task jo == i]) job_cost jo

subgoal 2 (ID 2715) is:
 forall (i : Task) (j0 : Job),
 i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0

----------------------------------------------------------------------------- *)


            rewrite (big_rem (job_task jo)) //=.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 2876)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  ARRo : jo \in jobs
  HEQ : EDF jo j
  TSKo : job_task jo != tsk
  ============================
  job_cost jo <=
  (if [&& job_task jo != tsk, EDF jo j & job_task jo == job_task jo]
   then job_cost jo
   else 0) +
  \sum_(y <- rem (T:=Task) (job_task jo) ts | [&& y != tsk, EDF jo j
                                                & 
                                              job_task jo == y]) 
  job_cost jo

subgoal 2 (ID 2899) is:
 job_task jo \in ts
subgoal 3 (ID 2715) is:
 forall (i : Task) (j0 : Job),
 i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0

----------------------------------------------------------------------------- *)


            rewrite /EDF_from HEQ eq_refl TSKo andTb andTb leq_addr //.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2899)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  ARRo : jo \in jobs
  HEQ : EDF jo j
  TSKo : job_task jo != tsk
  ============================
  job_task jo \in ts

subgoal 2 (ID 2715) is:
 forall (i : Task) (j0 : Job),
 i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0

----------------------------------------------------------------------------- *)


          - eapply H_all_jobs_from_taskset, in_arrivals_implies_arrived; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2715)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  forall (i : Task) (j0 : Job),
  i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0

----------------------------------------------------------------------------- *)


          - movetsko jo /negP NEQ /andP [EQ1 /eqP EQ2].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3050)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  jo : Job
  NEQ : ~ tsko == tsk
  EQ1 : EDF jo j
  EQ2 : job_task jo = tsko
  ============================
  EDF_not_from tsk jo

----------------------------------------------------------------------------- *)


            rewrite /EDF_not_from EQ1 Bool.andb_true_l; apply/negP; intros CONTR.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3078)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  jo : Job
  NEQ : ~ tsko == tsk
  EQ1 : EDF jo j
  EQ2 : job_task jo = tsko
  CONTR : job_task jo == tsk
  ============================
  False

----------------------------------------------------------------------------- *)


            apply: NEQ; clear EQ1.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3085)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  jo : Job
  EQ2 : job_task jo = tsko
  CONTR : job_task jo == tsk
  ============================
  tsko == tsk

----------------------------------------------------------------------------- *)


              by rewrite -EQ2.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


        Qed.

Next we focus on one task [tsk_o ≠ tsk] and consider two cases.
Case 1: [Δ ≤ A + ε + D tsk - D tsk_o].
        Section Case1.

Consider an arbitrary task [tsk_o ≠ tsk] from [ts].
          Variable tsk_o : Task.
          Hypothesis H_tsko_in_ts: tsk_o \in ts.
          Hypothesis H_neq: tsk_o != tsk.

And assume that [Δ ≤ A + ε + D tsk - D tsk_o].
          Hypothesis H_Δ_le: Δ A + ε + D tsk - D tsk_o.

Then by definition of [rbf], the total workload of jobs with higher-or-equal priority from task [tsk_o] is bounded [rbf(tsk_o, Δ)].
          Lemma workload_le_rbf:
            workload_of_jobs (EDF_from tsk_o) jobs rbf tsk_o Δ.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2603)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  workload_of_jobs (EDF_from tsk_o) jobs <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


          Proof.
            unfold workload_of_jobs, EDF_from.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2605)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  rbf tsk_o Δ

----------------------------------------------------------------------------- *)


            apply leq_trans with (task_cost tsk_o × number_of_task_arrivals tsk_o t1 (t1 + Δ)).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2608)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ)

subgoal 2 (ID 2609) is:
 task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


            {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2608)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ)

----------------------------------------------------------------------------- *)


apply leq_trans with (\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | job_task j0 == tsk_o)
                                     job_cost j0).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2622)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  job_task j0 == tsk_o) job_cost j0

subgoal 2 (ID 2623) is:
 \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
 job_task j0 == tsk_o) job_cost j0 <=
 task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ)

----------------------------------------------------------------------------- *)


              {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2622)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  job_task j0 == tsk_o) job_cost j0

----------------------------------------------------------------------------- *)


rewrite big_mkcond [X in _ X]big_mkcond //= leq_sum //.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2678)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  forall i : Job,
  true ->
  (if EDF i j && (job_task i == tsk_o) then job_cost i else 0) <=
  (if job_task i == tsk_o then job_cost i else 0)

----------------------------------------------------------------------------- *)


                  by intros s _; case (job_task s == tsk_o); case (EDF s j).
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2623)

subgoal 1 (ID 2623) is:
 \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
 job_task j0 == tsk_o) job_cost j0 <=
 task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ)
subgoal 2 (ID 2609) is:
 task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


}

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2623)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  job_task j0 == tsk_o) job_cost j0 <=
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ)

----------------------------------------------------------------------------- *)


              {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2623)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  job_task j0 == tsk_o) job_cost j0 <=
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ)

----------------------------------------------------------------------------- *)


rewrite /number_of_task_arrivals /task.arrivals.number_of_task_arrivals
                -sum1_size big_distrr /= big_filter muln1.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2755)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  job_task j0 == tsk_o) job_cost j0 <=
  \sum_(i <- arrivals_between arr_seq t1 (t1 + Δ) | 
  job_task i == tsk_o) task_cost tsk_o

----------------------------------------------------------------------------- *)


                apply leq_sum_seq; movejo IN0 /eqP EQ.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2792)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  jo : Job
  IN0 : jo \in arrivals_between arr_seq t1 (t1 + Δ)
  EQ : job_task jo = tsk_o
  ============================
  job_cost jo <= task_cost tsk_o

----------------------------------------------------------------------------- *)


                  by rewrite -EQ; apply H_valid_job_cost; apply in_arrivals_implies_arrived in IN0.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2609)

subgoal 1 (ID 2609) is:
 task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


              }

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2609)

subgoal 1 (ID 2609) is:
 task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


            }

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2609)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


            {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2609)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ

----------------------------------------------------------------------------- *)


rewrite leq_mul2l; apply/orP; right.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2829)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  number_of_task_arrivals tsk_o t1 (t1 + Δ) <= max_arrivals tsk_o Δ

----------------------------------------------------------------------------- *)


              rewrite -{2}[Δ](addKn t1).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2835)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_le : Δ <= A + ε + D tsk - D tsk_o
  ============================
  number_of_task_arrivals tsk_o t1 (t1 + Δ) <=
  max_arrivals tsk_o (t1 + Δ - t1)

----------------------------------------------------------------------------- *)


                by apply H_is_arrival_curve; auto using leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


            }

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


          Qed.

        End Case1.

Case 2: [A + ε + D tsk - D tsk_o ≤ Δ].
        Section Case2.

Consider an arbitrary task [tsk_o ≠ tsk] from [ts].
          Variable tsk_o : Task.
          Hypothesis H_tsko_in_ts: tsk_o \in ts.
          Hypothesis H_neq: tsk_o != tsk.

And assume that [A + ε + D tsk - D tsk_o ≤ Δ].
          Hypothesis H_Δ_ge: A + ε + D tsk - D tsk_o Δ.

Important step. Next we prove that the total workload of jobs with higher-or-equal priority from task [tsk_o] over time interval [t1, t1 + Δ] is bounded by workload over time interval [t1, t1 + A + ε + D tsk - D tsk_o]. The intuition behind this inequality is that jobs which arrive after time instant [t1 + A + ε + D tsk - D tsk_o] has smaller priority than job [j] due to the term [D tsk - D tsk_o].
          Lemma total_workload_shorten_range:
            workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + Δ))
             workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o))).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2607)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  ============================
  workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + Δ)) <=
  workload_of_jobs (EDF_from tsk_o)
    (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)))

----------------------------------------------------------------------------- *)


          Proof.
            unfold workload_of_jobs, EDF_from.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2609)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0

----------------------------------------------------------------------------- *)


            move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2680)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0

----------------------------------------------------------------------------- *)


            set (V := A + ε + D tsk - D tsk_o) in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2684)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0

----------------------------------------------------------------------------- *)


            rewrite (arrivals_between_cat _ _ (t1 + V)); [ |rewrite leq_addr //|rewrite leq_add2l //].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2699)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- (arrivals_between arr_seq t1 (t1 + V) ++
               arrivals_between arr_seq (t1 + V) (t1 + Δ)) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0

----------------------------------------------------------------------------- *)


            rewrite big_cat //=.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2721)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(i <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF i j && (job_task i == tsk_o)) job_cost i +
  \sum_(i <- arrivals_between arr_seq (t1 + V) (t1 + Δ) | 
  EDF i j && (job_task i == tsk_o)) job_cost i <=
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0

----------------------------------------------------------------------------- *)


            rewrite -[X in _ X]addn0 leq_add2l leqn0.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2761)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(i <- arrivals_between arr_seq (t1 + V) (t1 + Δ) | 
  EDF i j && (job_task i == tsk_o)) job_cost i == 0

----------------------------------------------------------------------------- *)


            rewrite big_seq_cond.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2770)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(i <- arrivals_between arr_seq (t1 + V) (t1 + Δ) | 
  [&& i \in arrivals_between arr_seq (t1 + V) (t1 + Δ), EDF i j
    & job_task i == tsk_o]) job_cost i == 0

----------------------------------------------------------------------------- *)


            apply/eqP; apply big_pred0.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2799)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  (fun i : Job =>
   [&& i \in arrivals_between arr_seq (t1 + V) (t1 + Δ), EDF i j
     & job_task i == tsk_o]) =1 xpred0

----------------------------------------------------------------------------- *)


            intros jo; apply/negP; intros CONTR.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2839)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  CONTR : [&& jo \in arrivals_between arr_seq (t1 + V) (t1 + Δ), EDF jo j
            & job_task jo == tsk_o]
  ============================
  False

----------------------------------------------------------------------------- *)


            move: CONTR ⇒ /andP [ARRIN /andP [HEP /eqP TSKo]].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2951)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  ARRIN : jo \in arrivals_between arr_seq (t1 + V) (t1 + Δ)
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  ============================
  False

----------------------------------------------------------------------------- *)


            eapply in_arrivals_implies_arrived_between in ARRIN; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2954)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  ARRIN : arrived_between jo (t1 + V) (t1 + Δ)
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  ============================
  False

----------------------------------------------------------------------------- *)


            move: ARRIN ⇒ /andP [ARRIN _]; unfold V in ARRIN.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3002)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  ============================
  False

----------------------------------------------------------------------------- *)


            edestruct (leqP (D tsk_o) (A + ε + D tsk)) as [NEQ2|NEQ2].
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3025)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  False

subgoal 2 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


            - move: ARRIN; rewrite leqNgt; move ⇒ /negP ARRIN; apply: ARRIN.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3064)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  job_arrival jo < t1 + (A + ε + D tsk - D tsk_o)

subgoal 2 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


              rewrite -(ltn_add2r (D tsk_o)).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3068)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  job_arrival jo + D tsk_o < t1 + (A + ε + D tsk - D tsk_o) + D tsk_o

subgoal 2 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


              apply leq_ltn_trans with (job_arrival j + D tsk); first by rewrite -H_job_of_tsk -TSKo.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3072)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  job_arrival j + D tsk < t1 + (A + ε + D tsk - D tsk_o) + D tsk_o

subgoal 2 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


              rewrite addnBA // addnA addnA subnKC // subnK.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 3152)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  job_arrival j + D tsk < job_arrival j + ε + D tsk

subgoal 2 (ID 3153) is:
 D tsk_o <= job_arrival j + ε + D tsk
subgoal 3 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


              + by rewrite ltn_add2r addn1.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3153)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  D tsk_o <= job_arrival j + ε + D tsk

subgoal 2 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


              + apply leq_trans with (A + ε + D tsk); first by done.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3163)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  NEQ2 : D tsk_o <= A + ε + D tsk
  ============================
  A + ε + D tsk <= job_arrival j + ε + D tsk

subgoal 2 (ID 3026) is:
 False

----------------------------------------------------------------------------- *)


                  by rewrite !leq_add2r leq_subr.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3026)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  HEP : EDF jo j
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  False

----------------------------------------------------------------------------- *)


            - move: HEP; rewrite /EDF /edf.EDF leqNgt; move ⇒ /negP HEP; apply: HEP.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3220)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  job_deadline j < job_deadline jo

----------------------------------------------------------------------------- *)



              apply leq_ltn_trans with (job_arrival jo + (A + D tsk)).
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3223)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  job_deadline j <= job_arrival jo + (A + D tsk)

subgoal 2 (ID 3224) is:
 job_arrival jo + (A + D tsk) < job_deadline jo

----------------------------------------------------------------------------- *)


              + rewrite subh1 // addnBA.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 3259)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  job_deadline j <= job_arrival jo + (job_arrival j + D tsk) - t1

subgoal 2 (ID 3260) is:
 t1 <= job_arrival j + D tsk
subgoal 3 (ID 3224) is:
 job_arrival jo + (A + D tsk) < job_deadline jo

----------------------------------------------------------------------------- *)


                rewrite [in X in _ X]addnC -addnBA.

(* ----------------------------------[ coqtop ]---------------------------------

4 subgoals (ID 3277)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  job_deadline j <= job_arrival j + D tsk + (job_arrival jo - t1)

subgoal 2 (ID 3278) is:
 t1 <= job_arrival jo
subgoal 3 (ID 3260) is:
 t1 <= job_arrival j + D tsk
subgoal 4 (ID 3224) is:
 job_arrival jo + (A + D tsk) < job_deadline jo

----------------------------------------------------------------------------- *)


                × by rewrite /job_deadline /job_deadline_from_task_deadline H_job_of_tsk leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 3278)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  t1 <= job_arrival jo

subgoal 2 (ID 3260) is:
 t1 <= job_arrival j + D tsk
subgoal 3 (ID 3224) is:
 job_arrival jo + (A + D tsk) < job_deadline jo

----------------------------------------------------------------------------- *)


                × by apply leq_trans with (t1 + (A + ε + D tsk - D tsk_o)); first rewrite leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3260)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  t1 <= job_arrival j + D tsk

subgoal 2 (ID 3224) is:
 job_arrival jo + (A + D tsk) < job_deadline jo

----------------------------------------------------------------------------- *)


                    by apply leq_trans with (job_arrival j); [ | by rewrite leq_addr].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3224)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  job_arrival jo + (A + D tsk) < job_deadline jo

----------------------------------------------------------------------------- *)


              + rewrite ltn_add2l.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3309)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  A + D tsk < task_deadline (job_task jo)

----------------------------------------------------------------------------- *)


                apply leq_ltn_trans with (A + ε + D tsk).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3310)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  A + D tsk <= A + ε + D tsk

subgoal 2 (ID 3311) is:
 A + ε + D tsk < task_deadline (job_task jo)

----------------------------------------------------------------------------- *)


                × by rewrite leq_add2r leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3311)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  jo : Job
  TSKo : job_task jo = tsk_o
  ARRIN : t1 + (A + ε + D tsk - D tsk_o) <= job_arrival jo
  NEQ2 : A + ε + D tsk < D tsk_o
  ============================
  A + ε + D tsk < task_deadline (job_task jo)

----------------------------------------------------------------------------- *)


                × by rewrite TSKo.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


          Qed.

And similarly to the previous case, by definition of [rbf], the total workload of jobs with higher-or-equal priority from task [tsk_o] is bounded [rbf(tsk_o, Δ)].
          Lemma workload_le_rbf':
            workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)))
             rbf tsk_o (A + ε + D tsk - D tsk_o).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2611)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  ============================
  workload_of_jobs (EDF_from tsk_o)
    (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o))) <=
  rbf tsk_o (A + ε + D tsk - D tsk_o)

----------------------------------------------------------------------------- *)


          Proof.
            unfold workload_of_jobs, EDF_from.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2613)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  rbf tsk_o (A + ε + D tsk - D tsk_o)

----------------------------------------------------------------------------- *)


            move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2684)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  rbf tsk_o (A + ε + D tsk - D tsk_o)

----------------------------------------------------------------------------- *)


            set (V := A + ε + D tsk - D tsk_o) in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2688)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <= 
  rbf tsk_o V

----------------------------------------------------------------------------- *)


            apply leq_trans with
                (task_cost tsk_o × number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2691)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  task_cost tsk_o *
  number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


            - apply leq_trans with
                   (\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | job_task jo == tsk_o) job_cost jo).

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 2705)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) | 
  EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
  \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
  job_task jo == tsk_o) job_cost jo

subgoal 2 (ID 2706) is:
 \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
 job_task jo == tsk_o) job_cost jo <=
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))
subgoal 3 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


               + rewrite big_mkcond [X in _ X]big_mkcond //=.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 2730)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(i <- arrivals_between arr_seq t1 (t1 + V))
     (if EDF i j && (job_task i == tsk_o) then job_cost i else 0) <=
  \sum_(i <- arrivals_between arr_seq t1 (t1 + V))
     (if job_task i == tsk_o then job_cost i else 0)

subgoal 2 (ID 2706) is:
 \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
 job_task jo == tsk_o) job_cost jo <=
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))
subgoal 3 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                 rewrite leq_sum //; intros s _.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 2790)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  s : Job
  ============================
  (if EDF s j && (job_task s == tsk_o) then job_cost s else 0) <=
  (if job_task s == tsk_o then job_cost s else 0)

subgoal 2 (ID 2706) is:
 \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
 job_task jo == tsk_o) job_cost jo <=
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))
subgoal 3 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                   by case (EDF s j).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2706)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
  job_task jo == tsk_o) job_cost jo <=
  task_cost tsk_o *
  number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


               + rewrite /number_of_task_arrivals /task.arrivals.number_of_task_arrivals
                 -sum1_size big_distrr /= big_filter.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2825)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
  job_task jo == tsk_o) job_cost jo <=
  \sum_(i <- arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)) | 
  job_task i == tsk_o) task_cost tsk_o * 1

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                 rewrite muln1.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2830)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | 
  job_task jo == tsk_o) job_cost jo <=
  \sum_(i <- arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)) | 
  job_task i == tsk_o) task_cost tsk_o

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                 apply leq_sum_seq; movej0 IN0 /eqP EQ.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2867)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  j0 : Job
  IN0 : j0 \in arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o))
  EQ : job_task j0 = tsk_o
  ============================
  job_cost j0 <= task_cost tsk_o

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                 rewrite -EQ.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2869)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  j0 : Job
  IN0 : j0 \in arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o))
  EQ : job_task j0 = tsk_o
  ============================
  job_cost j0 <= task_cost (job_task j0)

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                 apply H_valid_job_cost.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2870)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  j0 : Job
  IN0 : j0 \in arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o))
  EQ : job_task j0 = tsk_o
  ============================
  arrives_in arr_seq j0

subgoal 2 (ID 2692) is:
 task_cost tsk_o *
 number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
 rbf tsk_o V

----------------------------------------------------------------------------- *)


                   by apply in_arrivals_implies_arrived in IN0.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2692)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  task_cost tsk_o *
  number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
  rbf tsk_o V

----------------------------------------------------------------------------- *)


            - unfold V in *; clear V.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2876)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  task_cost tsk_o *
  number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
  rbf tsk_o (A + ε + D tsk - D tsk_o)

----------------------------------------------------------------------------- *)


              set (V := A + ε + D tsk - D tsk_o) in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2880)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + V) <= rbf tsk_o V

----------------------------------------------------------------------------- *)


              rewrite leq_mul2l; apply/orP; right.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2911)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  number_of_task_arrivals tsk_o t1 (t1 + V) <= max_arrivals tsk_o V

----------------------------------------------------------------------------- *)


              rewrite -{2}[V](addKn t1).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2917)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  tsk_o : Task
  H_tsko_in_ts : tsk_o \in ts
  H_neq : tsk_o != tsk
  V := A + ε + D tsk - D tsk_o : nat
  H_Δ_ge : V <= Δ
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  number_of_task_arrivals tsk_o t1 (t1 + V) <=
  max_arrivals tsk_o (t1 + V - t1)

----------------------------------------------------------------------------- *)


                by apply H_is_arrival_curve; auto using leq_addr.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


          Qed.

        End Case2.

By combining case 1 and case 2 we prove that total workload of tasks is at most [bound_on_total_hep_workload(A, Δ)].
        Corollary sum_of_workloads_is_at_most_bound_on_total_hep_workload :
          \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs
           bound_on_total_hep_workload A Δ.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2604)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  ============================
  \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs <=
  bound_on_total_hep_workload A Δ

----------------------------------------------------------------------------- *)


        Proof.
          move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2675)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs <=
  bound_on_total_hep_workload A Δ

----------------------------------------------------------------------------- *)


          apply leq_sum_seq; intros tsko INtsko NEQT.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2679)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  ============================
  workload_of_jobs (EDF_from tsko) jobs <=
  rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


          case: (leqP Δ (A + ε + D tsk - D tsko)) ⇒ NEQ.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2691)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : Δ <= A + ε + D tsk - D tsko
  ============================
  workload_of_jobs (EDF_from tsko) jobs <=
  rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

subgoal 2 (ID 2692) is:
 workload_of_jobs (EDF_from tsko) jobs <=
 rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


          {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2691)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : Δ <= A + ε + D tsk - D tsko
  ============================
  workload_of_jobs (EDF_from tsko) jobs <=
  rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


try (move: (NEQ); move⇒ /minn_idPr ->).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2726)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : Δ <= A + ε + D tsk - D tsko
  ============================
  workload_of_jobs (EDF_from tsko) jobs <= rbf tsko Δ

----------------------------------------------------------------------------- *)


(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
            now apply workload_le_rbf.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2692)

subgoal 1 (ID 2692) is:
 workload_of_jobs (EDF_from tsko) jobs <=
 rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


}

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2692)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : A + ε + D tsk - D tsko < Δ
  ============================
  workload_of_jobs (EDF_from tsko) jobs <=
  rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


          {

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2692)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : A + ε + D tsk - D tsko < Δ
  ============================
  workload_of_jobs (EDF_from tsko) jobs <=
  rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


            apply ltnW in NEQ.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2728)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : A + ε + D tsk - D tsko <= Δ
  ============================
  workload_of_jobs (EDF_from tsko) jobs <=
  rbf tsko (minn (A + ε + D tsk - D tsko) Δ)

----------------------------------------------------------------------------- *)


            try (move: (NEQ); move⇒ /minn_idPl ->).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2763)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : A + ε + D tsk - D tsko <= Δ
  ============================
  workload_of_jobs (EDF_from tsko) jobs <= rbf tsko (A + ε + D tsk - D tsko)

----------------------------------------------------------------------------- *)


(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
            eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------

2 focused subgoals
(shelved: 1) (ID 2765)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : A + ε + D tsk - D tsko <= Δ
  ============================
  workload_of_jobs (EDF_from tsko) jobs <= ?n

subgoal 2 (ID 2766) is:
 ?n <= rbf tsko (A + ε + D tsk - D tsko)

----------------------------------------------------------------------------- *)


eapply total_workload_shorten_range; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2766)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  H_j_arrives : arrives_in arr_seq j
  H_job_of_tsk : job_task j = tsk
  H_job_cost_positive : job_cost_positive j
  t1, t2 : duration
  H_busy_interval : busy_interval sched interference interfering_workload j
                      t1 t2
  A := job_arrival j - t1 : nat
  Δ : duration
  H_Δ_in_busy : t1 + Δ < t2
  jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
  EDF_from := fun (tsk : Task) (jo : Job) => EDF jo j && (job_task jo == tsk)
   : Task -> Job -> bool
  EDF_not_from := fun (tsk : Task) (jo : Job) =>
                  EDF jo j && (job_task jo != tsk) : 
  Task -> Job -> bool
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  tsko : Task
  INtsko : tsko \in ts
  NEQT : tsko != tsk
  NEQ : A + ε + D tsk - D tsko <= Δ
  ============================
  workload_of_jobs (EDF_from tsko)
    (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsko))) <=
  rbf tsko (A + ε + D tsk - D tsko)

----------------------------------------------------------------------------- *)


            now eapply workload_le_rbf'; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


}

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


        Qed.

    End Inequalities.

Recall that in module abstract_seq_RTA hypothesis task_interference_is_bounded_by expects to receive a function that maps some task t, the relative arrival time of a job j of task t, and the length of the interval to the maximum amount of interference.
However, in this module we analyze only one task -- [tsk], therefore it is “hard-coded” inside the interference bound function IBF. Therefore, in order for the IBF signature to match the required signature in module abstract_seq_RTA, we wrap the IBF function in a function that accepts, but simply ignores the task.
      Corollary instantiated_task_interference_is_bounded:
        task_interference_is_bounded_by
          arr_seq sched tsk interference interfering_workload (fun tsk A RIBF A R).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2542)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  task_interference_is_bounded_by arr_seq sched tsk interference
    interfering_workload (fun=> (fun A : duration => [eta IBF A]))

----------------------------------------------------------------------------- *)


      Proof.
        unfold EDF in ×.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2544)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  task_interference_is_bounded_by arr_seq sched tsk interference
    interfering_workload (fun=> (fun A : duration => [eta IBF A]))

----------------------------------------------------------------------------- *)


        intros j R2 t1 t2 ARR TSK N NCOMPL BUSY.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2554)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  ============================
  let offset := job_arrival j - t1 in
  cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
  IBF offset R2

----------------------------------------------------------------------------- *)


        move: (posnP (@job_cost _ H4 j)) ⇒ [ZERO|POS].

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2571)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  ZERO : job_cost j = 0
  ============================
  let offset := job_arrival j - t1 in
  cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
  IBF offset R2

subgoal 2 (ID 2572) is:
 let offset := job_arrival j - t1 in
 cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
 IBF offset R2

----------------------------------------------------------------------------- *)


        - exfalso; move: NCOMPL ⇒ /negP COMPL; apply: COMPL.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2607)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  ZERO : job_cost j = 0
  ============================
  completed_by sched j (t1 + R2)

subgoal 2 (ID 2572) is:
 let offset := job_arrival j - t1 in
 cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
 IBF offset R2

----------------------------------------------------------------------------- *)


            by rewrite /completed_by /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2572)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  ============================
  let offset := job_arrival j - t1 in
  cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
  IBF offset R2

----------------------------------------------------------------------------- *)


        - move: (BUSY) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2694)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  let offset := job_arrival j - t1 in
  cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
  IBF offset R2

----------------------------------------------------------------------------- *)


          rewrite (cumulative_task_interference_split arr_seq sched _ _ _ tsk j);
            eauto 2 with basic_facts; last first.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2733)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  j \in arrivals_before arr_seq t2

subgoal 2 (ID 2727) is:
 let offset := job_arrival j - t1 in
 cumulative_priority_inversion sched j t1 (t1 + R2) +
 cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
 IBF offset R2

----------------------------------------------------------------------------- *)


          {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2733)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  j \in arrivals_before arr_seq t2

----------------------------------------------------------------------------- *)


by eapply arrived_between_implies_in_arrivals; eauto.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2727)

subgoal 1 (ID 2727) is:
 let offset := job_arrival j - t1 in
 cumulative_priority_inversion sched j t1 (t1 + R2) +
 cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
 IBF offset R2

----------------------------------------------------------------------------- *)


}

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2727)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  let offset := job_arrival j - t1 in
  cumulative_priority_inversion sched j t1 (t1 + R2) +
  cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
  IBF offset R2

----------------------------------------------------------------------------- *)


          rewrite /I leq_add //.
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2776)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  cumulative_priority_inversion sched j t1 (t1 + R2) <=
  priority_inversion_bound

subgoal 2 (ID 2777) is:
 cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
 bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)



          + by apply cumulative_priority_inversion_is_bounded with t2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2777)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
  bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


          + eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------

2 focused subgoals
(shelved: 1) (ID 2828)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
  ?n

subgoal 2 (ID 2829) is:
 ?n <= bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


eapply cumulative_interference_is_bounded_by_total_service; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2829)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  service_of_jobs sched (fun jo : Job => EDF jo j && (job_task jo != tsk))
    (arrivals_between arr_seq t1 (t1 + R2)) t1 (t1 + R2) <=
  bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


            eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------

2 focused subgoals
(shelved: 1) (ID 2841)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  service_of_jobs sched (fun jo : Job => EDF jo j && (job_task jo != tsk))
    (arrivals_between arr_seq t1 (t1 + R2)) t1 (t1 + R2) <= 
  ?n

subgoal 2 (ID 2842) is:
 ?n <= bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


eapply total_service_is_bounded_by_total_workload; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2842)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  workload_of_jobs (fun jo : Job => EDF jo j && (job_task jo != tsk))
    (arrivals_between arr_seq t1 (t1 + R2)) <=
  bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


            eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------

2 focused subgoals
(shelved: 1) (ID 2844)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  workload_of_jobs (fun jo : Job => EDF jo j && (job_task jo != tsk))
    (arrivals_between arr_seq t1 (t1 + R2)) <= ?n

subgoal 2 (ID 2845) is:
 ?n <= bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


eapply reorder_summation; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2845)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(tsk_o <- ts | tsk_o != tsk)
     workload_of_jobs (fun jo : Job => EDF jo j && (job_task jo == tsk_o))
       (arrivals_between arr_seq t1 (t1 + R2)) <=
  bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


            eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------

2 focused subgoals
(shelved: 1) (ID 2849)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  \sum_(tsk_o <- ts | tsk_o != tsk)
     workload_of_jobs (fun jo : Job => EDF jo j && (job_task jo == tsk_o))
       (arrivals_between arr_seq t1 (t1 + R2)) <= 
  ?n

subgoal 2 (ID 2850) is:
 ?n <= bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


eapply sum_of_workloads_is_at_most_bound_on_total_hep_workload; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2850)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  j : Job
  R2, t1, t2 : nat
  ARR : arrives_in arr_seq j
  TSK : job_task j = tsk
  N : t1 + R2 < t2
  NCOMPL : ~~ completed_by sched j (t1 + R2)
  BUSY : busy_interval sched interference interfering_workload j t1 t2
  POS : 0 < job_cost j
  JINBI : t1 <= job_arrival j
  JINBI2 : job_arrival j < t2
  QT : quiet_time sched interference interfering_workload j t1
  ============================
  bound_on_total_hep_workload (job_arrival j - t1) R2 <=
  bound_on_total_hep_workload (job_arrival j - t1) R2

----------------------------------------------------------------------------- *)


              by done.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)



      Qed.

    End TaskInterferenceIsBoundedByIBF.

Finally, we show that there exists a solution for the response-time recurrence.
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.

Given any job j of task [tsk] that arrives exactly A units after the beginning of the busy interval, the bound of the total interference incurred by j within an interval of length Δ is equal to [task_rbf (A + ε) - task_cost tsk + IBF(A, Δ)].
      Let total_interference_bound tsk (A Δ : duration) :=
        task_rbf (A + ε) - task_cost tsk + IBF A Δ.

Next, consider any A from the search space (in abstract sense).
      Variable A : duration.
      Hypothesis H_A_is_in_abstract_search_space:
        search_space.is_in_search_space tsk L total_interference_bound A.

We prove that A is also in the concrete search space.
      Lemma A_is_in_concrete_search_space:
        is_in_search_space A.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2545)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  ============================
  is_in_search_space A

----------------------------------------------------------------------------- *)


      Proof.
        move: H_A_is_in_abstract_search_space ⇒ [INSP | [/andP [POSA LTL] [x [LTx INSP2]]]].

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2559)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  INSP : A = 0
  ============================
  is_in_search_space A

subgoal 2 (ID 2629) is:
 is_in_search_space A

----------------------------------------------------------------------------- *)


        {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2559)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  INSP : A = 0
  ============================
  is_in_search_space A

----------------------------------------------------------------------------- *)


subst A.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2635)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound 0
  ============================
  is_in_search_space 0

----------------------------------------------------------------------------- *)


          apply/andP; split; [by done | apply/orP; left].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2688)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound 0
  ============================
  task_rbf_changes_at 0

----------------------------------------------------------------------------- *)


          rewrite /task_rbf_changes_at neq_ltn; apply/orP; left.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2719)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound 0
  ============================
  task_rbf 0 < task_rbf (0 + ε)

----------------------------------------------------------------------------- *)


          rewrite /task_rbf /rbf; erewrite task_rbf_0_zero; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2724)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound 0
  ============================
  0 < task_request_bound_function tsk (0 + ε)

----------------------------------------------------------------------------- *)


          rewrite add0n /task_rbf; apply leq_trans with (task_cost tsk).

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2761)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound 0
  ============================
  0 < task_cost tsk

subgoal 2 (ID 2762) is:
 task_cost tsk <= task_request_bound_function tsk ε

----------------------------------------------------------------------------- *)


          - by eapply leq_trans; eauto 2;
              rewrite -(eqbool_to_eqprop H_job_of_tsk); apply H_valid_job_cost.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2762)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound 0
  ============================
  task_cost tsk <= task_request_bound_function tsk ε

----------------------------------------------------------------------------- *)


          - by eapply task_rbf_1_ge_task_cost; eauto using eqbool_to_eqprop.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2629)

subgoal 1 (ID 2629) is:
 is_in_search_space A

----------------------------------------------------------------------------- *)


        }

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2629)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : total_interference_bound tsk (A - ε) x <>
          total_interference_bound tsk A x
  ============================
  is_in_search_space A

----------------------------------------------------------------------------- *)


        {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2629)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : total_interference_bound tsk (A - ε) x <>
          total_interference_bound tsk A x
  ============================
  is_in_search_space A

----------------------------------------------------------------------------- *)


apply/andP; split; first by done.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2860)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : total_interference_bound tsk (A - ε) x <>
          total_interference_bound tsk A x
  ============================
  task_rbf_changes_at A || bound_on_total_hep_workload_changes_at A

----------------------------------------------------------------------------- *)


          rewrite -[_ || _ ]Bool.negb_involutive negb_or; apply/negP; move ⇒ /andP [/negPn/eqP EQ1 /hasPn EQ2].

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3014)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : total_interference_bound tsk (A - ε) x <>
          total_interference_bound tsk A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  EQ2 : {in ts,
          forall x : Task,
          ~~
          ((tsk != x) &&
           (rbf x (A + D tsk - D x) != rbf x (A + ε + D tsk - D x)))}
  ============================
  False

----------------------------------------------------------------------------- *)


          unfold total_interference_bound in × ;apply INSP2.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3017)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  EQ2 : {in ts,
          forall x : Task,
          ~~
          ((tsk != x) &&
           (rbf x (A + D tsk - D x) != rbf x (A + ε + D tsk - D x)))}
  ============================
  task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x =
  task_rbf (A + ε) - task_cost tsk + IBF A x

----------------------------------------------------------------------------- *)


          rewrite subn1 addn1 prednK // -EQ1.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3053)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  EQ2 : {in ts,
          forall x : Task,
          ~~
          ((tsk != x) &&
           (rbf x (A + D tsk - D x) != rbf x (A + ε + D tsk - D x)))}
  ============================
  task_rbf A - task_cost tsk + IBF (predn A) x =
  task_rbf A - task_cost tsk + IBF A x

----------------------------------------------------------------------------- *)


          apply/eqP; rewrite eqn_add2l eqn_add2l.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3118)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  EQ2 : {in ts,
          forall x : Task,
          ~~
          ((tsk != x) &&
           (rbf x (A + D tsk - D x) != rbf x (A + ε + D tsk - D x)))}
  ============================
  bound_on_total_hep_workload (predn A) x == bound_on_total_hep_workload A x

----------------------------------------------------------------------------- *)


          apply: eq_sum_seq; intros tsk_o IN NEQ.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3149)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  EQ2 : {in ts,
          forall x : Task,
          ~~
          ((tsk != x) &&
           (rbf x (A + D tsk - D x) != rbf x (A + ε + D tsk - D x)))}
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  ============================
  rbf tsk_o (minn (predn A + ε + D tsk - D tsk_o) x) ==
  rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


          rewrite addn1 prednK //.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3156)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  EQ2 : {in ts,
          forall x : Task,
          ~~
          ((tsk != x) &&
           (rbf x (A + D tsk - D x) != rbf x (A + ε + D tsk - D x)))}
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  ============================
  rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
  rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


          move: (EQ2 tsk_o IN); clear EQ2;
            rewrite eq_sym NEQ Bool.andb_true_l Bool.negb_involutive; move ⇒ /eqP EQ2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3229)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  ============================
  rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
  rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


          edestruct (leqP (A + ε + D tsk - D tsk_o) x) as [CASE|CASE].
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3252)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  ============================
  rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
  rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

subgoal 2 (ID 3253) is:
 rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


          - have ->: minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 3256)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  ============================
  minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o

subgoal 2 (ID 3261) is:
 rbf tsk_o (A + D tsk - D tsk_o) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
subgoal 3 (ID 3253) is:
 rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


            {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3256)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  ============================
  minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o

----------------------------------------------------------------------------- *)


rewrite minnE.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3265)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  ============================
  A + D tsk - D tsk_o - (A + D tsk - D tsk_o - x) = A + D tsk - D tsk_o

----------------------------------------------------------------------------- *)


              have CASE2: A + D tsk - D tsk_o x
                by apply leq_trans with (A + ε + D tsk - D tsk_o);
                  first (apply leq_sub2r; rewrite leq_add2r leq_addr).

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3280)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  CASE2 : A + D tsk - D tsk_o <= x
  ============================
  A + D tsk - D tsk_o - (A + D tsk - D tsk_o - x) = A + D tsk - D tsk_o

----------------------------------------------------------------------------- *)


                now move: CASE2; rewrite -subn_eq0; move ⇒ /eqP CASE2; rewrite CASE2 subn0.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3261)

subgoal 1 (ID 3261) is:
 rbf tsk_o (A + D tsk - D tsk_o) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
 rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


            }
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3261)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  ============================
  rbf tsk_o (A + D tsk - D tsk_o) ==
  rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

subgoal 2 (ID 3253) is:
 rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)



            try (move: (CASE); move⇒ /minn_idPl ->).
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3361)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : A + ε + D tsk - D tsk_o <= x
  ============================
  rbf tsk_o (A + D tsk - D tsk_o) == rbf tsk_o (A + ε + D tsk - D tsk_o)

subgoal 2 (ID 3253) is:
 rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
 rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
            now apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3253)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  ============================
  rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
  rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


          - have ->: minn (A + D tsk - D tsk_o) x = x.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3392)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  ============================
  minn (A + D tsk - D tsk_o) x = x

subgoal 2 (ID 3397) is:
 rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


            {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3392)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  ============================
  minn (A + D tsk - D tsk_o) x = x

----------------------------------------------------------------------------- *)


rewrite minnE; rewrite subKn //; rewrite -(leq_add2r 1) !addn1 -subSn.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 3446)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  ============================
  x < succn (A + D tsk) - D tsk_o

subgoal 2 (ID 3447) is:
 D tsk_o <= A + D tsk

----------------------------------------------------------------------------- *)


              + now rewrite -[in X in _ X]addn1 -addnA [_ + 1]addnC addnA.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3447)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  ============================
  D tsk_o <= A + D tsk

----------------------------------------------------------------------------- *)


              + enough (POS: 0 < A + ε + D tsk - D tsk_o); last eapply leq_ltn_trans with x; eauto 2.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3480)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  POS : 0 < A + ε + D tsk - D tsk_o
  ============================
  D tsk_o <= A + D tsk

----------------------------------------------------------------------------- *)


                now rewrite subn_gt0 -addnA [1 + _]addnC addnA addn1 ltnS in POS.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3397)

subgoal 1 (ID 3397) is:
 rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)


            }
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3397)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  CASE : x < A + ε + D tsk - D tsk_o
  ============================
  rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)

----------------------------------------------------------------------------- *)



            try (apply ltnW in CASE; move: CASE; move⇒ /minn_idPl; rewrite minnC ⇒ ->).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 3649)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      (fun (tsk : Task) (A Δ : duration) =>
                                       task_rbf (A + ε) - task_cost tsk +
                                       IBF A Δ) A
  POSA : 0 < A
  LTL : A < L
  x : nat
  LTx : x < L
  INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
          task_rbf (A + ε) - task_cost tsk + IBF A x
  EQ1 : task_rbf A = task_rbf (A + ε)
  tsk_o : Task
  IN : tsk_o \in ts
  NEQ : tsk_o != tsk
  EQ2 : rbf tsk_o (A + D tsk - D tsk_o) = rbf tsk_o (A + ε + D tsk - D tsk_o)
  ============================
  rbf tsk_o x == rbf tsk_o x

----------------------------------------------------------------------------- *)


(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
            now apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


        }

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


      Qed.

Then, there exists solution for response-time recurrence (in the abstract sense).
      Corollary correct_search_space:
         F,
          A + F = task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) + IBF A (A + F)
          F + (task_cost tsk - task_run_to_completion_threshold tsk) R.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2558)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  ============================
  exists F : nat,
    A + F =
    task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
    IBF A (A + F) /\
    F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


      Proof.
        edestruct H_R_is_maximum as [F [FIX NEQ]].

(* ----------------------------------[ coqtop ]---------------------------------

2 focused subgoals
(shelved: 1) (ID 2562)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  ============================
  is_in_search_space ?A

subgoal 2 (ID 2572) is:
 exists F0 : nat,
   A + F0 =
   task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
   IBF A (A + F0) /\
   F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


        - by apply A_is_in_concrete_search_space.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2572)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  F : duration
  FIX : A + F =
        priority_inversion_bound +
        (task_rbf (A + ε) -
         (task_cost tsk - task_run_to_completion_threshold tsk)) +
        bound_on_total_hep_workload A (A + F)
  NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
  ============================
  exists F0 : nat,
    A + F0 =
    task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
    IBF A (A + F0) /\
    F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


        - F; split; last by done.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2576)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  F : duration
  FIX : A + F =
        priority_inversion_bound +
        (task_rbf (A + ε) -
         (task_cost tsk - task_run_to_completion_threshold tsk)) +
        bound_on_total_hep_workload A (A + F)
  NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
  ============================
  A + F =
  task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
  IBF A (A + F)

----------------------------------------------------------------------------- *)


          apply/eqP; rewrite {1}FIX.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2634)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> 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
  total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
                              task_rbf (A + ε) - task_cost tsk + IBF A Δ
   : Task -> duration -> duration -> nat
  A : duration
  H_A_is_in_abstract_search_space : search_space.is_in_search_space tsk L
                                      total_interference_bound A
  F : duration
  FIX : A + F =
        priority_inversion_bound +
        (task_rbf (A + ε) -
         (task_cost tsk - task_run_to_completion_threshold tsk)) +
        bound_on_total_hep_workload A (A + F)
  NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
  ============================
  priority_inversion_bound +
  (task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk)) +
  bound_on_total_hep_workload A (A + F) ==
  task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
  IBF A (A + F)

----------------------------------------------------------------------------- *)


            by rewrite addnA [_ + priority_inversion_bound]addnC -!addnA.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


      Qed.

      End SolutionOfResponseTimeReccurenceExists.

  End FillingOutHypothesesOfAbstractRTATheorem.

Final Theorem

Based on the properties established above, we apply the abstract analysis framework to infer that R is a response-time bound for [tsk].
  Theorem uniprocessor_response_time_bound_edf:
    response_time_bounded_by tsk R.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2519)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  ============================
  response_time_bounded_by tsk R

----------------------------------------------------------------------------- *)


  Proof.
    intros js ARRs TSKs.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2523)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  ============================
  job_response_time_bound sched js R

----------------------------------------------------------------------------- *)


    move: (posnP (@job_cost _ H4 js)) ⇒ [ZERO|POS].

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2540)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  ZERO : job_cost js = 0
  ============================
  job_response_time_bound sched js R

subgoal 2 (ID 2541) is:
 job_response_time_bound sched js R

----------------------------------------------------------------------------- *)


    {
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2540)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  ZERO : job_cost js = 0
  ============================
  job_response_time_bound sched js R

----------------------------------------------------------------------------- *)


by rewrite /job_response_time_bound /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2541)

subgoal 1 (ID 2541) is:
 job_response_time_bound sched js R

----------------------------------------------------------------------------- *)


}
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2541)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  job_response_time_bound sched js R

----------------------------------------------------------------------------- *)


   
    eapply uniprocessor_response_time_bound_seq with
        (interference0 := interference) (interfering_workload0 := interfering_workload)
        (task_interference_bound_function := fun tsk A RIBF A R) (L0 := L); eauto 3.

(* ----------------------------------[ coqtop ]---------------------------------

5 subgoals (ID 2583)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  work_conserving arr_seq sched tsk interference interfering_workload

subgoal 2 (ID 2585) is:
 interference_and_workload_consistent_with_sequential_tasks arr_seq sched tsk
   interference interfering_workload
subgoal 3 (ID 2586) is:
 busy_intervals_are_bounded_by arr_seq sched tsk interference
   interfering_workload L
subgoal 4 (ID 2587) is:
 task_interference_is_bounded_by arr_seq sched tsk interference
   interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 5 (ID 2588) is:
 forall A : duration,
 search_space.is_in_search_space tsk L
   (fun (tsk0 : Task) (A0 Δ : duration) =>
    task_request_bound_function tsk (A0 + ε) - task_cost tsk0 + IBF A0 Δ) A ->
 exists F : duration,
   A + F =
   task_request_bound_function tsk (A + ε) -
   (task_cost tsk - task_run_to_completion_threshold tsk) + 
   IBF A (A + F) /\
   F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


    - by apply instantiated_i_and_w_are_coherent_with_schedule.

(* ----------------------------------[ coqtop ]---------------------------------

4 subgoals (ID 2585)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  interference_and_workload_consistent_with_sequential_tasks arr_seq sched
    tsk interference interfering_workload

subgoal 2 (ID 2586) is:
 busy_intervals_are_bounded_by arr_seq sched tsk interference
   interfering_workload L
subgoal 3 (ID 2587) is:
 task_interference_is_bounded_by arr_seq sched tsk interference
   interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 4 (ID 2588) is:
 forall A : duration,
 search_space.is_in_search_space tsk L
   (fun (tsk0 : Task) (A0 Δ : duration) =>
    task_request_bound_function tsk (A0 + ε) - task_cost tsk0 + IBF A0 Δ) A ->
 exists F : duration,
   A + F =
   task_request_bound_function tsk (A + ε) -
   (task_cost tsk - task_run_to_completion_threshold tsk) + 
   IBF A (A + F) /\
   F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


    - by apply instantiated_interference_and_workload_consistent_with_sequential_tasks.

(* ----------------------------------[ coqtop ]---------------------------------

3 subgoals (ID 2586)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  busy_intervals_are_bounded_by arr_seq sched tsk interference
    interfering_workload L

subgoal 2 (ID 2587) is:
 task_interference_is_bounded_by arr_seq sched tsk interference
   interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 3 (ID 2588) is:
 forall A : duration,
 search_space.is_in_search_space tsk L
   (fun (tsk0 : Task) (A0 Δ : duration) =>
    task_request_bound_function tsk (A0 + ε) - task_cost tsk0 + IBF A0 Δ) A ->
 exists F : duration,
   A + F =
   task_request_bound_function tsk (A + ε) -
   (task_cost tsk - task_run_to_completion_threshold tsk) + 
   IBF A (A + F) /\
   F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


    - by apply instantiated_busy_intervals_are_bounded.

(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2587)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  task_interference_is_bounded_by arr_seq sched tsk interference
    interfering_workload (fun=> (fun A : duration => [eta IBF A]))

subgoal 2 (ID 2588) is:
 forall A : duration,
 search_space.is_in_search_space tsk L
   (fun (tsk0 : Task) (A0 Δ : duration) =>
    task_request_bound_function tsk (A0 + ε) - task_cost tsk0 + IBF A0 Δ) A ->
 exists F : duration,
   A + F =
   task_request_bound_function tsk (A + ε) -
   (task_cost tsk - task_run_to_completion_threshold tsk) + 
   IBF A (A + F) /\
   F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


    - by apply instantiated_task_interference_is_bounded.

(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2588)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  forall A : duration,
  search_space.is_in_search_space tsk L
    (fun (tsk0 : Task) (A0 Δ : duration) =>
     task_request_bound_function tsk (A0 + ε) - task_cost tsk0 + IBF A0 Δ) A ->
  exists F : duration,
    A + F =
    task_request_bound_function tsk (A + ε) -
    (task_cost tsk - task_run_to_completion_threshold tsk) + 
    IBF A (A + F) /\
    F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R

----------------------------------------------------------------------------- *)


    - eapply correct_search_space; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2610)
  
  Task : TaskType
  H : TaskCost Task
  H0 : TaskDeadline Task
  H1 : TaskRunToCompletionThreshold Task
  Job : JobType
  H2 : JobTask Job Task
  H3 : JobArrival Job
  H4 : JobCost Job
  H5 : JobPreemptable Job
  D := [eta task_deadline] : Task -> duration
  EDF := edf.EDF Job : JLFP_policy Job
  arr_seq : arrival_sequence Job
  H_arrival_times_are_consistent : consistent_arrival_times arr_seq
  H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
  sched : schedule (processor_state Job)
  H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
                                        arr_seq
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  work_conserving_ab := work_conserving arr_seq sched
   : Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
  work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
  H_work_conserving : work_conserving_cl
  H_sequential_tasks : sequential_tasks arr_seq sched
  H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
  ts : seq Task
  H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
  H6 : MaxArrivals Task
  H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
  H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
  tsk : Task
  H_tsk_in_ts : tsk \in ts
  H_valid_preemption_model : valid_preemption_model arr_seq sched
  H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
                                          arr_seq tsk
  rbf := task_request_bound_function : Task -> duration -> nat
  task_rbf := rbf tsk : duration -> nat
  total_rbf := total_request_bound_function ts : duration -> nat
  response_time_bounded_by := task_response_time_bound arr_seq sched
   : Task -> duration -> Prop
  number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
   : Task -> instant -> instant -> nat
  priority_inversion_bound : duration
  H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
                                      sched tsk priority_inversion_bound
  L : duration
  H_L_positive : 0 < L
  H_fixed_point : L = total_rbf L
  bound_on_total_hep_workload := fun A Δ : duration =>
                                 \sum_(tsk_o <- ts | 
                                 tsk_o != tsk)
                                    rbf tsk_o
                                      (minn (A + ε + D tsk - D tsk_o) Δ)
   : duration -> duration -> nat
  R : duration
  H_R_is_maximum : forall A : duration,
                   is_in_search_space A ->
                   exists F : duration,
                     A + F =
                     priority_inversion_bound +
                     (task_rbf (A + ε) -
                      (task_cost tsk - task_run_to_completion_threshold tsk)) +
                     bound_on_total_hep_workload A (A + F) /\
                     F +
                     (task_cost tsk - task_run_to_completion_threshold tsk) <=
                     R
  interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
   : Job -> instant -> bool
  interfering_workload := fun j : Job =>
                          [eta ideal_jlfp_rta.interfering_workload arr_seq
                                 sched j] : Job -> instant -> nat
  IBF := fun A R : duration =>
         priority_inversion_bound + bound_on_total_hep_workload A R
   : duration -> duration -> nat
  js : Job
  ARRs : arrives_in arr_seq js
  TSKs : job_task js = tsk
  POS : 0 < job_cost js
  ============================
  job_of_task tsk js

----------------------------------------------------------------------------- *)


by apply/eqP.

(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

----------------------------------------------------------------------------- *)


  Qed.

End AbstractRTAforEDFwithArrivalCurves.