From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "_ + _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ - _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ < _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ >= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ > _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ <= _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ * _" was already used in scope nat_scope.
[notation-overridden,parsing]

Require Import prosa.model.readiness.basic.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.model.priority.fifo.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.analysis.facts.priority.fifo.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.analysis.abstract.ideal_jlfp_rta.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.facts.busy_interval.carry_in.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]

(** * Abstract RTA for FIFO-schedulers *)
(** In this module we instantiate the Abstract Response-Time analysis
    (aRTA) to FIFO schedulers for real-time tasks with arbitrary arrival models
     assuming an ideal uni-processor model. *)

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

Section AbstractRTAforFIFOwithArrivalCurves.

  (** Consider any type of tasks, each characterized by a WCET, a relative
      deadline, and a run-to-completion threshold, ... *)
  Context {Task : TaskType}.
  Context `{TaskCost Task}.
  Context `{TaskDeadline Task}.
  Context `{TaskRunToCompletionThreshold Task}.

  (**  ... and any type of jobs associated with these tasks, where each
       each job has an arrival time, a cost, and a preemption-point predicate. *)
  Context {Job : JobType}.
  Context `{JobTask Job Task}.
  Context {Arrival : JobArrival Job}.
  Context {Cost : JobCost Job}.
  Context `{JobPreemptable Job}.

  (** We assume the classic (i.e., Liu & Layland) model of readiness
      without jitter or self-suspensions, wherein pending jobs are
      always ready. *)
  #[local] Existing Instance basic_ready_instance.

  (** Consider any arrival sequence with consistent, non-duplicate arrivals. *)
  Variable arr_seq : arrival_sequence Job.
  Hypothesis H_arrival_times_are_consistent : consistent_arrival_times arr_seq.
  Hypothesis H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq.

  (** Next, consider any valid ideal uni-processor schedule of this arrival sequence. *)
  Variable sched : schedule (ideal.processor_state Job).
  Hypothesis H_valid_schedule : valid_schedule sched arr_seq.

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

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

  (** Assume that a job's cost cannot be larger than its task's WCET. *)
  Hypothesis H_valid_job_cost : arrivals_have_valid_job_costs arr_seq.

  (** Consider an arbitrary task set [ts]. *)
  Variable ts : list Task.

  (** Next, we assume that all jobs come from the task set. *)
  Hypothesis H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts.

  (** 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) a monotonic function 
     that equals 0 for the empty interval [delta = 0]. *)
  Context `{MaxArrivals Task}.
  Hypothesis H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals.
  Hypothesis H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts.

  (** 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... *)
  Hypothesis H_valid_preemption_model : valid_preemption_model arr_seq sched.

  (** ...and a valid task run-to-completion threshold function. That
      is, [task_rtct tsk] is (1) no larger than [tsk]'s cost, (2) for
      any job of task [tsk], [job_rtct] is bounded by [task_rtct]. *)
  Hypothesis H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold arr_seq tsk.

  (** We also assume that the schedule respects the policy defined by the preemption model. *)
  Hypothesis H_respects_policy_at_preemption_point : respects_JLFP_policy_at_preemption_point arr_seq sched (FIFO Job). 

  (** We introduce [rbf] as an abbreviation of the task request bound function,
      which is defined as [task_cost(T) × max_arrivals(T,Δ)] for a given task [T]. *)
  Let rbf := task_request_bound_function.

  (** Next, we introduce [task_rbf] as an abbreviation 
      of the task request bound function of task [tsk]. *)
   Let task_rbf := rbf tsk. 

  (** For simplicity, let's define some local names. *)
  Let response_time_bounded_by := task_response_time_bound arr_seq sched.
  Let number_of_task_arrivals := number_of_task_arrivals arr_seq.

  (** 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_request_bound_function ts L.

  (** To reduce the time complexity of the analysis, we introduce the notion of search space for FIFO.
      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 the case of FIFO, the final search space is the set of offsets less than [L] 
      such that there exists a task [tsko] from [ts] such that [rbf tsko (A) ≠ rbf tsko (A + ε)]. *)
  Definition is_in_search_space (A : duration) :=
    (A < L) && has (fun tsko => rbf tsko (A) != rbf tsko ( A + ε )) ts.

  (** Let [R] be a value that upper-bounds the solution of each
      response-time equation, i.e., for any relative arrival time [A]
      in the search space, there exists a corresponding solution [F]
      such that [R >= F]. *)
  Variable R : duration.
  Hypothesis H_R_is_maximum: 
    forall (A : duration),
      is_in_search_space A -> 
      exists (F : nat),
        A + F >= \sum_(tsko <- ts) rbf tsko (A + ε) /\
        F <= R.

  (** To use the theorem [uniprocessor_response_time_bound] from the Abstract RTA module, 
      we need to specify functions that concretely define the abstract concepts
      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. *)
  Let interfering_workload (j : Job) (t : instant) := ideal_jlfp_rta.interfering_workload arr_seq sched j t.

  (** Finally, we define the interference bound function ([IBF]). [IBF] bounds the cumulative 
      interference incurred by a job. For FIFO, we define [IBF] as the sum of [RBF] for all tasks 
      in the interval [A + ε] minus the WCET of [tsk]. *)
  Let IBF tsk (A R : duration) := (\sum_(tsko <- ts) rbf tsko (A + ε)) - task_cost tsk.

  (** ** Filling Out Hypotheses Of Abstract RTA Theorem *)
  (** In this section we prove that all hypotheses necessary to use the abstract theorem are satisfied. *)
  Section FillingOutHypothesesOfAbstractRTATheorem.

    (** 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.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L
    Proof.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L
      move => j ARR TSK POS.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2
      edestruct exists_busy_interval_from_total_workload_bound
        with (Δ := L) as [t1 [t2 [T1 [T2 GGG]]]]; rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
forall t : instant,
workload_of_jobs predT
  (arrivals_between arr_seq t (t + L)) <= L
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2
      {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
forall t : instant,
workload_of_jobs predT
  (arrivals_between arr_seq t (t + L)) <= L by intros; rewrite {2}H_fixed_point; apply total_workload_le_total_rbf. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2
      {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
exists t1 t2 : nat,
  t2 <= t1 + L /\
  definitions.busy_interval sched interference
    interfering_workload j t1 t2 exists t1, t2; split; first by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
ARR: arrives_in arr_seq j
TSK: job_of_task tsk j
POS: 0 < job_cost j
t1, t2: nat
T1: t1 <= job_arrival j < t2
T2: t2 <= t1 + L
GGG: busy_interval arr_seq sched j t1 t2
definitions.busy_interval sched interference
  interfering_workload j t1 t2
        by eapply instantiated_busy_interval_equivalent_busy_interval; rt_eauto. }
    Qed.

    (** In this section, we prove that, under FIFO scheduling, the cumulative priority inversion experienced
        by a job [j] in any interval within its busy window is always [0]. We later use this fact to prove the bound on 
        the cumulative interference. *)
    Section PriorityInversion.

      (** Consider any job [j] of the task under consideration [tsk]. *)
      Variable j : Job.
      Hypothesis H_j_arrives : arrives_in arr_seq j.
      Hypothesis H_job_of_tsk : job_task j = tsk.

      (** Assume that the job has a positive cost. *)
      Hypothesis H_job_cost_positive: job_cost_positive j.

      (** Assume the busy interval of the job is given by <<[t1,t2)>>. *)
      Variable t1 t2 : duration.
      Hypothesis H_busy_interval :
        definitions.busy_interval sched interference interfering_workload j t1 t2.

      (** Consider any interval <<[t1,t1 + Δ)>> in the busy interval of [j]. *)
      Variable Δ : duration.
      Hypothesis H_Δ_in_busy : t1 + Δ < t2.

      (** We prove that the cumulative priority inversion in the interval <<[t1, t1 + Δ)>> is [0]. *)
      Lemma cumulative_priority_inversion_is_bounded:
        cumulative_priority_inversion sched j t1 (t1 + Δ) = 0.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
cumulative_priority_inversion sched j t1 (t1 + Δ) = 0
      Proof.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
cumulative_priority_inversion sched j t1 (t1 + Δ) = 0
        apply big_nat_eq0 => t /andP [T1 T2].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
is_priority_inversion sched j t = 0
        apply /eqP; rewrite eqb0; apply /negP.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
~ is_priority_inversion sched j t
        move: (ideal_proc_model_sched_case_analysis sched t) => [/eqP IDLE|[s INTER]];
                                                                 first by rewrite  /is_priority_inversion IDLE.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
~ is_priority_inversion sched j t
        destruct (leqP (job_arrival j) t).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
~ is_priority_inversion sched j t
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
~ is_priority_inversion sched j t
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
~ is_priority_inversion sched j t destruct (completed_by sched j t) eqn : COMPL; last first.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = false
~ is_priority_inversion sched j t
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = true
~ is_priority_inversion sched j t
          {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = false
~ is_priority_inversion sched j t apply /negP.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = false
~~ is_priority_inversion sched j t
            eapply (FIFO_implies_no_priority_inversion arr_seq); rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = false
pending sched j t
            by apply /andP; split; [| rewrite COMPL]. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = true
~ is_priority_inversion sched j t
          {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: job_arrival j <= t
COMPL: completed_by sched j t = true
~ is_priority_inversion sched j t rewrite scheduled_at_def in INTER.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t == Some s
~ is_priority_inversion sched j t
            rewrite /is_priority_inversion.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t == Some s
~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end 
            move: INTER => /eqP INTER; rewrite INTER.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
~ ~~ hep_job s j
            apply /negP; rewrite Bool.negb_involutive /hep_job /FIFO.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
job_arrival s <= job_arrival j
            move_neq_up CONTR.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
False
             have QTIme' : quiet_time arr_seq sched j t.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
quiet_time arr_seq sched j t
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
False
            {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
quiet_time arr_seq sched j t move => j_hp ARRjhp HEP ARRbef.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
completed_by sched j_hp t
              eapply (scheduled_implies_higher_priority_completed arr_seq _ _ _ _ s); try by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
scheduled_at sched s t
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
~~ hep_job s j_hp
              -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
scheduled_at sched s t
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
~~ hep_job s j_hp by move : INTER => /eqP INTER; rewrite -scheduled_at_def in INTER.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
~~ hep_job s j_hp
              -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
~~ hep_job s j_hp by rewrite -ltnNge; apply leq_ltn_trans with (job_arrival j). }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
False 
            apply instantiated_busy_interval_equivalent_busy_interval in H_busy_interval;
              rt_eauto; last by [].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
False
            move : H_busy_interval => [ [_ [_ [QUIET /andP [ARR _ ]]]] _].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
False
            destruct (leqP t t1) as [LE | LT].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LE: t <= t1
False
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False
            {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LE: t <= t1
False have EQ : t = job_arrival j by apply eq_trans with t1; lia.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LE: t <= t1
EQ: t = job_arrival j
False
              rewrite EQ in COMPL; apply completed_on_arrival_implies_zero_cost in COMPL; rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LE: t <= t1
EQ: t = job_arrival j
COMPL: job_cost j = 0
False
              by move: (H_job_cost_positive); rewrite /job_cost_positive COMPL. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False
            {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False specialize (QUIET t); feed QUIET.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
t1 < t < t2
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False
              -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
t1 < t < t2
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False apply /andP; split; first by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: t1 < t < t2 -> ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
t < t2
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False
                by apply leq_trans with (t1 +  Δ) ; [| apply ltnW].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False
              -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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 arr_seq sched j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
QTIme': quiet_time arr_seq sched j t
QUIET: ~ quiet_time arr_seq sched j t
ARR: t1 <= job_arrival j
LT: t1 < t
False by contradict QUIET. } } }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
~ is_priority_inversion sched j t
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
~ is_priority_inversion sched j t have MUST : jobs_must_be_ready_to_execute sched.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
jobs_must_be_ready_to_execute sched
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
MUST: jobs_must_be_ready_to_execute sched
~ is_priority_inversion sched j t
          {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
jobs_must_be_ready_to_execute sched exact: (valid_schedule_jobs_must_be_ready_to_execute sched arr_seq). }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
MUST: jobs_must_be_ready_to_execute sched
~ is_priority_inversion sched j t
          have HAS : has_arrived s t by eapply (jobs_must_arrive_to_be_ready  sched).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
INTER: scheduled_at sched s t
i: t < job_arrival j
MUST: jobs_must_be_ready_to_execute sched
HAS: has_arrived s t
~ is_priority_inversion sched j t
          rewrite scheduled_at_def in INTER.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: t < job_arrival j
MUST: jobs_must_be_ready_to_execute sched
HAS: has_arrived s t
INTER: sched t == Some s
~ is_priority_inversion sched j t
          unfold is_priority_inversion.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: t < job_arrival j
MUST: jobs_must_be_ready_to_execute sched
HAS: has_arrived s t
INTER: sched t == Some s
~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end
          move: INTER => /eqP ->; apply /negP; rewrite Bool.negb_involutive.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: t < job_arrival j
MUST: jobs_must_be_ready_to_execute sched
HAS: has_arrived s t
hep_job s j
          by apply leq_trans with t; [apply HAS | apply ltnW].
          Unshelve.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
valid_schedule sched arr_seq
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
valid_preemption_model arr_seq sched
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> 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: definitions.busy_interval sched
  interference interfering_workload
  j t1 t2
Δ: duration
H_Δ_in_busy: t1 + Δ < t2
t: nat
T1: t1 <= t
T2: t < t1 + Δ
s: Job
i: job_arrival j <= t
COMPL: completed_by sched j t = true
INTER: sched t = Some s
CONTR: job_arrival j < job_arrival s
j_hp: Job
ARRjhp: arrives_in arr_seq j_hp
HEP: hep_job j_hp j
ARRbef: arrived_before j_hp t
respects_JLFP_policy_at_preemption_point arr_seq sched
  (FIFO Job)
          all: by []. }
      Qed.

    End PriorityInversion.

    (** Using the above lemma, we prove that IBF is indeed an interference bound. *)
    Lemma instantiated_interference_is_bounded :
      job_interference_is_bounded_by arr_seq sched tsk interference interfering_workload  IBF.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload IBF
    Proof.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload IBF
      move => t1 t2 Δ j ARRj TSKj BUSY IN_BUSY NCOMPL.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
let offset := job_arrival j - t1 in
cumul_interference interference j t1 (t1 + Δ) <=
IBF tsk offset Δ
      rewrite /cumul_interference cumulative_interference_split.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
ideal_jlfp_rta.cumulative_priority_inversion sched j
  t1 (t1 + Δ) +
\sum_(t1 <= t < t1 + Δ)
   is_interference_from_another_hep_job sched j t <=
IBF tsk (job_arrival j - t1) Δ
      have JPOS: job_cost_positive j by rewrite -ltnNge in NCOMPL; unfold job_cost_positive; lia.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
ideal_jlfp_rta.cumulative_priority_inversion sched j
  t1 (t1 + Δ) +
\sum_(t1 <= t < t1 + Δ)
   is_interference_from_another_hep_job sched j t <=
IBF tsk (job_arrival j - t1) Δ
      move: (BUSY) => [ [ /andP [LE GT] [QUIETt1 _ ] ] [QUIETt2 EQNs]].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
ideal_jlfp_rta.cumulative_priority_inversion sched j
  t1 (t1 + Δ) +
\sum_(t1 <= t < t1 + Δ)
   is_interference_from_another_hep_job sched j t <=
IBF tsk (job_arrival j - t1) Δ
      erewrite (cumulative_priority_inversion_is_bounded j ARRj JPOS t1 t2); rewrite //= add0n.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(t1 <= t < t1 + Δ)
   is_interference_from_another_hep_job sched j t <=
IBF tsk (job_arrival j - t1) Δ
      rewrite (instantiated_cumulative_interference_of_hep_jobs_equal_total_interference_of_hep_jobs arr_seq) //=; 
              try by (try rewrite instantiated_quiet_time_equivalent_quiet_time); rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
service_of_jobs sched
  (fun jhp : Job => hep_job jhp j && (jhp != j))
  (arrivals_between arr_seq t1 (t1 + Δ)) t1 (t1 + Δ) <=
IBF tsk (job_arrival j - t1) Δ
      eapply leq_trans; first by apply service_of_jobs_le_workload; rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
workload_of_jobs
  (fun jhp : Job => hep_job jhp j && (jhp != j))
  (arrivals_between arr_seq t1 (t1 + Δ)) <=
IBF tsk (job_arrival j - t1) Δ
      rewrite (leqRW (workload_equal_subset _ _ _ _ _ _  _)); rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
workload_of_jobs (fun j0 : Job => j0 != j)
  (arrivals_between arr_seq t1 (job_arrival j + ε)) <=
IBF tsk (job_arrival j - t1) Δ
      specialize (workload_minus_job_cost j) => ->.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
workload_of_jobs predT
  (arrivals_between arr_seq t1 (job_arrival j + ε)) -
job_cost j <= IBF tsk (job_arrival j - t1) Δ
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
uniq (arrivals_between arr_seq t1 (job_arrival j + ε))
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j \in arrivals_between arr_seq t1 (job_arrival j + ε)
      {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
workload_of_jobs predT
  (arrivals_between arr_seq t1 (job_arrival j + ε)) -
job_cost j <= IBF tsk (job_arrival j - t1) Δ rewrite /workload_of_jobs /IBF (big_rem tsk) //= (addnC (rbf tsk (job_arrival j - t1 + ε))).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j -
job_cost j <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
rbf tsk (job_arrival j - t1 + ε) - task_cost tsk
        rewrite -addnBA; last first.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
task_cost tsk <= rbf tsk (job_arrival j - t1 + ε)
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
           (job_arrival j + ε)) 
job_cost j - 
job_cost j <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
(rbf tsk (job_arrival j - t1 + ε) - task_cost tsk)
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
task_cost tsk <= rbf tsk (job_arrival j - t1 + ε) apply leq_trans with (task_rbf ε).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
task_cost tsk <= task_rbf ε
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
task_rbf ε <= rbf tsk (job_arrival j - t1 + ε)
          ( try ( apply (task_rbf_1_ge_task_cost arr_seq) with (j0 := j) => //= ) ||
          apply (task_rbf_1_ge_task_cost arr_seq) with (j := j) => //=); first by auto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
task_rbf ε <= rbf tsk (job_arrival j - t1 + ε)
          by apply task_rbf_monotone; [apply H_valid_arrival_curve | lia]. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j -
job_cost j <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
(rbf tsk (job_arrival j - t1 + ε) - task_cost tsk)
        eapply leq_trans; last first.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
?n <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
(rbf tsk (job_arrival j - t1 + ε) - task_cost tsk)
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
           (job_arrival j + ε)) 
job_cost j - 
job_cost j <= 
?n
        by erewrite leq_add2l; eapply task_rbf_excl_tsk_bounds_task_workload_excl_j; eauto 1.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j -
job_cost j <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
(task_workload_between arr_seq tsk t1
   (t1 + (job_arrival j - t1) + ε) - job_cost j)
        rewrite addnBA.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j -
job_cost j <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε) - job_cost j
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
job_cost j <=
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε)
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j -
job_cost j <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε) - job_cost j rewrite leq_sub2r //; eapply leq_trans.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j <= ?n
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
?n <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε)
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(j <- arrivals_between arr_seq t1
             (job_arrival j + ε)) job_cost j <= ?n
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
?n <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε) apply sum_over_partitions_le => j' inJOBS.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j': Job
inJOBS: j'
  \in arrivals_between arr_seq t1
        (job_arrival j + ε)
?x_to_y j' \in ?ys
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(y <- ?ys)
   \sum_(x <- 
   arrivals_between arr_seq t1 
     (job_arrival j + ε) | 
   xpredT x && 
   (?x_to_y x == y)) 
   job_cost x <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε)
            by apply H_all_jobs_from_taskset, (in_arrivals_implies_arrived _ _ _ _ inJOBS).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(y <- ts)
   \sum_(x <- arrivals_between arr_seq t1
                (job_arrival j + ε) | xpredT x &&
                                      ([eta job_task]
                                         x == y))
      job_cost x <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε) 
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(y <- ts)
   \sum_(x <- arrivals_between arr_seq t1
                (job_arrival j + ε) | xpredT x &&
                                      ([eta job_task]
                                         x == y))
      job_cost x <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε) +
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε) rewrite (big_rem tsk) //= addnC leq_add //; last by rewrite subnKC.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(y <- rem (T:=Task) tsk ts)
   \sum_(x <- arrivals_between arr_seq t1
                (job_arrival j + ε) | job_task x == y)
      job_cost x <=
\sum_(y <- rem (T:=Task) tsk ts)
   rbf y (job_arrival j - t1 + ε)
            rewrite big_seq_cond [in X in _ <= X]big_seq_cond big_mkcond [in X in _ <= X]big_mkcond //=.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
\sum_(i <- rem (T:=Task) tsk ts)
   (if (i \in rem (T:=Task) tsk ts) && true
    then
     \sum_(x <- arrivals_between arr_seq t1
                  (job_arrival j + ε) | job_task x ==
                                        i) job_cost x
    else 0) <=
\sum_(i <- rem (T:=Task) tsk ts)
   (if (i \in rem (T:=Task) tsk ts) && true
    then rbf i (job_arrival j - t1 + ε)
    else 0) 
            apply leq_sum => tsk' _; rewrite andbC //=.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
(if tsk' \in rem (T:=Task) tsk ts
 then
  \sum_(x <- arrivals_between arr_seq t1
               (job_arrival j + ε) | job_task x ==
                                     tsk') job_cost x
 else 0) <=
(if tsk' \in rem (T:=Task) tsk ts
 then rbf tsk' (job_arrival j - t1 + ε)
 else 0)
            destruct (tsk' \in rem (T:=Task) tsk ts) eqn:IN; last by [].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: (tsk' \in rem (T:=Task) tsk ts) = true
\sum_(x <- arrivals_between arr_seq t1
             (job_arrival j + ε) | job_task x == tsk')
   job_cost x <= rbf tsk' (job_arrival j - t1 + ε)
            apply rem_in in IN.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
\sum_(x <- arrivals_between arr_seq t1
             (job_arrival j + ε) | job_task x == tsk')
   job_cost x <= rbf tsk' (job_arrival j - t1 + ε)
            eapply leq_trans; last first.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
?n <= rbf tsk' (job_arrival j - t1 + ε)
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
\sum_(x <- arrivals_between arr_seq t1
           (job_arrival j + ε) | 
job_task x == tsk') 
job_cost x <= 
?n
            +
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
?n <= rbf tsk' (job_arrival j - t1 + ε)
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
\sum_(x <- arrivals_between arr_seq t1
           (job_arrival j + ε) | 
job_task x == tsk') 
job_cost x <= 
?n by apply (task_workload_le_task_rbf _ _ _ IN H_valid_job_cost H_is_arrival_curve t1).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
\sum_(x <- arrivals_between arr_seq t1
             (job_arrival j + ε) | job_task x == tsk')
   job_cost x <=
workload_of_jobs (job_of_task tsk')
  (arrivals_between arr_seq t1
     (t1 + (job_arrival j - t1 + ε)))
            +
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
tsk': Task
IN: tsk' \in ts
\sum_(x <- arrivals_between arr_seq t1
             (job_arrival j + ε) | job_task x == tsk')
   job_cost x <=
workload_of_jobs (job_of_task tsk')
  (arrivals_between arr_seq t1
     (t1 + (job_arrival j - t1 + ε))) by rewrite addnBAC //= subnKC //= addn1; apply leqW. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
job_cost j <=
task_workload_between arr_seq tsk t1
  (t1 + (job_arrival j - t1) + ε)
        rewrite /task_workload_between /task_workload /workload_of_jobs (big_rem j) //=.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
job_cost j <=
(if job_of_task tsk j then job_cost j else 0) +
\sum_(y <- rem (T:=Job) j
             (arrivals_between arr_seq t1
                (t1 + (job_arrival j - t1) + ε)) | 
job_of_task tsk y) job_cost y
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j
  \in arrivals_between arr_seq t1
        (t1 + (job_arrival j - t1) + ε)
        -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
job_cost j <=
(if job_of_task tsk j then job_cost j else 0) +
\sum_(y <- rem (T:=Job) j
             (arrivals_between arr_seq t1
                (t1 + (job_arrival j - t1) + ε)) | 
job_of_task tsk y) job_cost y
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j
  \in arrivals_between arr_seq t1
        (t1 + (job_arrival j - t1) + ε) by rewrite TSKj; apply leq_addr.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j
  \in arrivals_between arr_seq t1
        (t1 + (job_arrival j - t1) + ε)
        -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j
  \in arrivals_between arr_seq t1
        (t1 + (job_arrival j - t1) + ε) apply job_in_arrivals_between => //.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
t1 <= job_arrival j < t1 + (job_arrival j - t1) + ε
          by apply /andP; split; [| rewrite subnKC; [rewrite addn1 |]].  }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
uniq (arrivals_between arr_seq t1 (job_arrival j + ε))
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j \in arrivals_between arr_seq t1 (job_arrival j + ε)
      apply: arrivals_uniq => //.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
j \in arrivals_between arr_seq t1 (job_arrival j + ε)
      apply: job_in_arrivals_between => //.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
t1, t2: instant
Δ: nat
j: Job
ARRj: arrives_in arr_seq j
TSKj: job_of_task tsk j
BUSY: definitions.busy_interval sched interference
  interfering_workload j t1 t2
IN_BUSY: t1 + Δ < t2
NCOMPL: ~~ completed_by sched j (t1 + Δ)
JPOS: job_cost_positive j
LE: t1 <= job_arrival j
GT: job_arrival j < t2
QUIETt1: definitions.quiet_time sched interference
  interfering_workload j t1
QUIETt2: cumul_interference interference j 0 t2 =
cumul_interfering_workload
  interfering_workload j 0 t2
EQNs: ~~ pending_earlier_and_at sched j t2
t1 <= job_arrival j < job_arrival j + ε
      by apply /andP; split; [ | rewrite addn1].
    Qed.

    (** Finally, we show that there exists a solution for the response-time equation. *)
    Section SolutionOfResponseTimeReccurenceExists.

      (** 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_positive_cost : 0 < task_cost tsk.
      
      (** Next, consider any [A] from the search space (in the abstract sense). *)
      Variable A : nat.
      Hypothesis H_A_is_in_abstract_search_space:
        search_space.is_in_search_space tsk L IBF A.

      (** We prove that [A] is also in the concrete search space. In other words, 
          we prove that the abstract search space is a subset of the concrete search space. *)
      Lemma A_is_in_concrete_search_space:
        is_in_search_space A.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
is_in_search_space A
      Proof.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
is_in_search_space A
        move: H_A_is_in_abstract_search_space => [INSP | [/andP [POSA LTL] [x [LTx INSP2]]]].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
INSP: A = 0
is_in_search_space A
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
is_in_search_space A
        unfold is_in_search_space.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
INSP: A = 0
(A < L) &&
has
  (fun tsko : Task => rbf tsko A != rbf tsko (A + ε))
  ts
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
is_in_search_space A
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
INSP: A = 0
(A < L) &&
has
  (fun tsko : Task => rbf tsko A != rbf tsko (A + ε))
  ts subst A.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
(0 < L) &&
has
  (fun tsko : Task => rbf tsko 0 != rbf tsko (0 + ε))
  ts 
          apply/andP; split; [by done |].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
has
  (fun tsko : Task => rbf tsko 0 != rbf tsko (0 + ε))
  ts
          apply /hasP.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
exists2 x : Task, x \in ts & rbf x 0 != rbf x (0 + ε) exists tsk; first by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
rbf tsk 0 != rbf tsk (0 + ε)
          rewrite neq_ltn;apply/orP; left.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
rbf tsk 0 < rbf tsk (0 + ε)
          rewrite /task_rbf /rbf; erewrite task_rbf_0_zero; eauto 2.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
0 < task_request_bound_function tsk (0 + ε)
          rewrite add0n /task_rbf; apply leq_trans with (task_cost tsk).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
0 < task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
task_cost tsk <= task_request_bound_function tsk ε
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
0 < task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
task_cost tsk <= task_request_bound_function tsk ε by eapply leq_trans; eauto 2.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
task_cost tsk <= task_request_bound_function tsk ε
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF 0
task_cost tsk <= task_request_bound_function tsk ε by eapply task_rbf_1_ge_task_cost; eauto. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
is_in_search_space A
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
is_in_search_space A apply /andP; split; first by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
has
  (fun tsko : Task => rbf tsko A != rbf tsko (A + ε))
  ts
          apply /hasPn.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
~
{in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
          move => EQ2.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: IBF tsk (A - ε) x <> IBF tsk A x
EQ2: {in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
False unfold IBF in INSP2.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
INSP2: \sum_(tsko <- ts) rbf tsko (A - ε + ε) -
task_cost tsk <>
\sum_(tsko <- ts) rbf tsko (A + ε) -
task_cost tsk
EQ2: {in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
False
          rewrite subnK in INSP2; try by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
EQ2: {in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
INSP2: \sum_(tsko <- ts) rbf tsko A - task_cost tsk <>
\sum_(tsko <- ts) rbf tsko (A + ε) -
task_cost tsk
False
          apply INSP2; clear INSP2.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
EQ2: {in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
\sum_(tsko <- ts) rbf tsko A - task_cost tsk =
\sum_(tsko <- ts) rbf tsko (A + ε) - task_cost tsk
          have -> : \sum_(tsko <- ts) rbf tsko A = \sum_(tsko <- ts) rbf tsko (A + ε); last by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
EQ2: {in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
\sum_(tsko <- ts) rbf tsko A =
\sum_(tsko <- ts) rbf tsko (A + ε)
          apply eq_big_seq => //= task IN.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
POSA: 0 < A
LTL: A < L
x: nat
LTx: x < L
EQ2: {in ts,
  forall x : Task, ~~ (rbf x A != rbf x (A + ε))}
task: Task
IN: task \in ts
rbf task A = rbf task (A + ε)
          by move: (EQ2 task IN) => /negPn /eqP. }
      Qed.

      
      (** Then, there exists a solution for the response-time recurrence (in the abstract sense). *)
      Corollary exists_solution_for_abstract_response_time_recurrence:
        exists (F : nat),
          A + F >= task_rtct tsk + IBF tsk A (A + F) /\
          F + (task_cost tsk - task_rtct tsk) <= R.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
      Proof.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        move : H_R_is_maximum => ABC.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F /\
  F <= R
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        move: (H_valid_arrival_curve _ H_tsk_in_ts) => VARR.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        move: (H_is_arrival_curve _ H_tsk_in_ts) => RESP.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        move : H_job_of_tsk => /eqP EQj.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R 
        specialize (ABC 0); feed ABC.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: is_in_search_space 0 ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
is_in_search_space 0
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: is_in_search_space 0 ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
is_in_search_space 0 apply /andP; split;  [by done| apply /hasP; exists tsk; first by done].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: is_in_search_space 0 ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
rbf tsk 0 != rbf tsk (0 + ε)
          rewrite /task_rbf /rbf task_rbf_0_zero //= (add0n ε) neq_ltn.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: is_in_search_space 0 ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
(0 < task_request_bound_function tsk ε)
|| (task_request_bound_function tsk ε < 0)
          apply /orP; left.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: is_in_search_space 0 ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
0 < task_request_bound_function tsk ε
          by apply (task_rbf_epsilon_gt_0 arr_seq H_arrival_times_are_consistent tsk RESP  j). }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
ABC: exists F : nat,
  \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F /\
  F <= R
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        move : ABC => [F [LE1 LE2]].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        edestruct H_R_is_maximum as [F' [FIX NEQ]]; first by apply A_is_in_concrete_search_space.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
        exists (R - (task_cost tsk - task_rtct tsk)); split.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk +
IBF tsk A (A + (R - (task_cost tsk - task_rtct tsk))) <=
A + (R - (task_cost tsk - task_rtct tsk))
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
R - (task_cost tsk - task_rtct tsk) +
(task_cost tsk - task_rtct tsk) <= R
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk +
IBF tsk A (A + (R - (task_cost tsk - task_rtct tsk))) <=
A + (R - (task_cost tsk - task_rtct tsk)) unfold IBF.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk +
(\sum_(tsko <- ts) rbf tsko (A + ε) - task_cost tsk) <=
A + (R - (task_cost tsk - task_rtct tsk))
          rewrite (leqRW FIX) addnC -subnA; first last.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_cost tsk <= A + F'
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk))
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_cost tsk <= A + F'
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk)) rewrite -(leqRW FIX).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_cost tsk <= \sum_(tsko <- ts) rbf tsko (A + ε)
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk))
            apply (task_cost_le_sum_rbf _ H_arrival_times_are_consistent _ VARR RESP j) => //.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
0 < A + ε
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk))
            by rewrite addn1.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk))
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk)) destruct H_valid_run_to_completion_threshold as [TASKvalid JOBvalid].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
TASKvalid: task_rtc_bounded_by_cost tsk
JOBvalid: job_respects_task_rtc arr_seq tsk
task_rtct tsk <= task_cost tsk
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk))
            by apply TASKvalid.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk)) 
          -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
A + F' - (task_cost tsk - task_rtct tsk) <=
A + (R - (task_cost tsk - task_rtct tsk)) rewrite addnBA; first by rewrite leq_sub2r // leq_add2l.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_cost tsk - task_rtct tsk <= R
            have GE: task_cost tsk <= R; last by lia.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_cost tsk <= R
            rewrite !add0n in LE1.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
LE1: \sum_(tsko <- ts) rbf tsko ε <= F
task_cost tsk <= R
            rewrite -(leqRW LE2) -(leqRW LE1).
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
LE1: \sum_(tsko <- ts) rbf tsko ε <= F
task_cost tsk <= \sum_(tsko <- ts) rbf tsko ε
            by eapply (task_cost_le_sum_rbf arr_seq); rt_eauto. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
R - (task_cost tsk - task_rtct tsk) +
(task_cost tsk - task_rtct tsk) <= R
        {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
R - (task_cost tsk - task_rtct tsk) +
(task_cost tsk - task_rtct tsk) <= R rewrite subnK; first by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE1: \sum_(tsko <- ts) rbf tsko (0 + ε) <= 0 + F
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
task_cost tsk - task_rtct tsk <= R
          rewrite !add0n in LE1.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
LE1: \sum_(tsko <- ts) rbf tsko ε <= F
task_cost tsk - task_rtct tsk <= R apply leq_trans with F; last by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
LE1: \sum_(tsko <- ts) rbf tsko ε <= F
task_cost tsk - task_rtct tsk <= F
          apply leq_trans with (\sum_(tsko <- ts) rbf tsko ε); last by done.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
LE1: \sum_(tsko <- ts) rbf tsko ε <= F
task_cost tsk - task_rtct tsk <=
\sum_(tsko <- ts) rbf tsko ε
          apply leq_trans with (task_cost tsk); first by lia.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_of_tsk: job_of_task tsk j
H_positive_cost: 0 < task_cost tsk
A: nat
H_A_is_in_abstract_search_space: search_space.is_in_search_space
  tsk L IBF A
VARR: valid_arrival_curve (max_arrivals tsk)
RESP: respects_max_arrivals arr_seq tsk
  (max_arrivals tsk)
EQj: job_task j = tsk
F: nat
LE2: F <= R
F': nat
FIX: \sum_(tsko <- ts) rbf tsko (A + ε) <= A + F'
NEQ: F' <= R
LE1: \sum_(tsko <- ts) rbf tsko ε <= F
task_cost tsk <= \sum_(tsko <- ts) rbf tsko ε
          eapply task_cost_le_sum_rbf; rt_eauto. }
      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_FIFO:
    response_time_bounded_by tsk R.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
response_time_bounded_by tsk R
  Proof.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
response_time_bounded_by tsk R
    intros js ARRs TSKs.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
job_response_time_bound sched js R
    move: (posnP (@job_cost _ Cost js)) => [ZERO|POS].
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
ZERO: job_cost js = 0
job_response_time_bound sched js R
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_response_time_bound sched js R
    {
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
ZERO: job_cost js = 0
job_response_time_bound sched js R by rewrite /job_response_time_bound /completed_by ZERO. }
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_response_time_bound sched js R    
    ( try ( eapply uniprocessor_response_time_bound with
      (interference0 := interference) (interfering_workload0 := interfering_workload)
      (interference_bound_function := fun tsk A R => IBF tsk A R) (L0 := L) ) ||
    eapply uniprocessor_response_time_bound with
      (interference := interference) (interfering_workload := interfering_workload)
      (interference_bound_function := fun tsk A R => IBF tsk A R) (L := L)); rt_eauto.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
definitions.work_conserving arr_seq sched interference
  interfering_workload
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload
  (fun (tsk : Task) (A : duration) => [eta IBF tsk A])
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
    -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
definitions.work_conserving arr_seq sched interference
  interfering_workload
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload
  (fun (tsk : Task) (A : duration) => [eta IBF tsk A])
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R  by eapply instantiated_i_and_w_are_coherent_with_schedule; rt_eauto; last
       by move => j1 j2 SAME ARR.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload
  (fun (tsk : Task) (A : duration) => [eta IBF tsk A])
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
    -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
busy_intervals_are_bounded_by arr_seq sched tsk
  interference interfering_workload L
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload
  (fun (tsk : Task) (A : duration) => [eta IBF tsk A])
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R by apply instantiated_busy_intervals_are_bounded.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload
  (fun (tsk : Task) (A : duration) => [eta IBF tsk A])
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
    -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_interference_is_bounded_by arr_seq sched tsk
  interference interfering_workload
  (fun (tsk : Task) (A : duration) => [eta IBF tsk A])
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R by apply instantiated_interference_is_bounded.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R
    -
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
forall A : nat,
search_space.is_in_search_space tsk L
  (fun (tsk : Task) (A0 : duration) =>
   [eta IBF tsk A0]) A ->
exists F : nat,
  task_rtct tsk + IBF tsk A (A + F) <= A + F /\
  F + (task_cost tsk - task_rtct tsk) <= R eapply (exists_solution_for_abstract_response_time_recurrence js) => //=.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
0 < task_cost tsk
      apply leq_trans with (job_cost js) => //.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
TSKs: job_of_task tsk js
POS: 0 < job_cost js
job_cost js <= task_cost tsk
      move: TSKs; rewrite /job_of_task => /eqP <-.
Task: TaskType
H: TaskCost Task
H0: TaskDeadline Task
H1: TaskRunToCompletionThreshold Task
Job: JobType
H2: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
H3: JobPreemptable Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
H_arr_seq_is_a_set: arrival_sequence_uniq arr_seq
sched: schedule (ideal.processor_state Job)
H_valid_schedule: valid_schedule sched arr_seq
work_conserving_ab:= definitions.work_conserving
  arr_seq sched: (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop
work_conserving_cl:= work_conserving arr_seq sched: Prop
H_work_conserving: work_conserving_cl
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
H4: 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
H_respects_policy_at_preemption_point: respects_JLFP_policy_at_preemption_point
  arr_seq sched
  (FIFO Job)
rbf:= task_request_bound_function: Task -> duration -> nat
task_rbf:= rbf tsk: 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
L: duration
H_L_positive: 0 < L
H_fixed_point: L = total_request_bound_function ts L
R: duration
H_R_is_maximum: forall A : duration,
is_in_search_space A ->
exists F : nat,
  \sum_(tsko <- ts) rbf tsko (A + ε) <=
  A + F /\ F <= 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 (tsk : Task) (A : duration) =>
fun=> \sum_(tsko <- ts) rbf tsko (A + ε) -
      task_cost tsk: Task -> duration -> duration -> nat
js: Job
ARRs: arrives_in arr_seq js
POS: 0 < job_cost js
job_cost js <= task_cost (job_task js)
      by eapply H_valid_job_cost.
  Qed.
  
End AbstractRTAforFIFOwithArrivalCurves.