Require Export prosa.model.task.preemption.parameters.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "_ + _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ - _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ < _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ >= _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ > _" was already used in scope nat_scope.
[notation-overridden,parsing]
Notation "_ <= _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ <= _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ < _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]
Notation "_ * _" was already used in scope nat_scope.
[notation-overridden,parsing]
Require Export prosa.model.schedule.priority_driven.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.model.schedule.work_conserving.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.definitions.job_properties.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.definitions.busy_interval.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.facts.model.ideal.schedule.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.facts.busy_interval.busy_interval.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.facts.model.preemption.
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.behavior.completion.
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]
Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]

(** Throughout this file, we assume ideal uni-processor schedules. *)
Require Import prosa.model.processor.ideal.
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]

(** * Priority inversion is bounded *)
(** In this module we prove that any priority inversion that occurs in the model with bounded 
    nonpreemptive segments defined in module prosa.model.schedule.uni.limited.platform.definitions 
    is bounded. *)
Section PriorityInversionIsBounded.

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

  (**  ... and any type of jobs associated with these tasks. *)
  Context {Job : JobType}.
  Context `{JobTask Job Task}.
  Context `{Arrival : JobArrival Job}.
  Context `{Cost : JobCost Job}.
  
  (** Consider any arrival sequence with consistent arrivals ... *)
  Variable arr_seq : arrival_sequence Job.
  Hypothesis H_arrival_times_are_consistent : consistent_arrival_times arr_seq.

  (** ... and any ideal uniprocessor schedule of this arrival sequence. *)
  Variable sched : schedule (ideal.processor_state Job).
 
  (** Consider a JLFP policy that indicates a higher-or-equal priority relation,
      and assume that the relation is reflexive and transitive. *)
  Context {JLFP : JLFP_policy Job}.
  Hypothesis H_priority_is_reflexive: reflexive_priorities.
  Hypothesis H_priority_is_transitive: transitive_priorities.

  (** In addition, we assume the existence of a function mapping a
      task to its maximal non-preemptive segment ... *)
  Context `{TaskMaxNonpreemptiveSegment Task}.

  (** ... and the existence of a function mapping a job and its
      progress to a boolean value saying whether this job is
      preemptable at its current point of execution. *)
  Context `{JobPreemptable Job}.

  (** And assume that they define a valid preemption model with
     bounded nonpreemptive segments. *)
  Hypothesis H_valid_model_with_bounded_nonpreemptive_segments:
    valid_model_with_bounded_nonpreemptive_segments arr_seq sched.

  (** Further, allow for any work-bearing notion of job readiness. *)
  Context `{@JobReady Job (ideal.processor_state Job) Cost Arrival}.
  Hypothesis H_job_ready : work_bearing_readiness arr_seq sched.

  (** We assume that the schedule is valid and that all jobs come from the arrival sequence. *)
  Hypothesis H_sched_valid : valid_schedule sched arr_seq.
  Hypothesis H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence sched arr_seq.
  
  (** Next, we assume that the schedule is a work-conserving schedule... *)
  Hypothesis H_work_conserving : work_conserving arr_seq sched.
  
  (** ... and the schedule respects the policy defined by the
       predicate [job_preemptable] (i.e., bounded nonpreemptive
       segments). *)
  Hypothesis H_respects_policy:
    respects_JLFP_policy_at_preemption_point arr_seq sched JLFP.
  
  (** Let's define some local names for clarity. *)
  Let job_scheduled_at := scheduled_at sched.
  Let job_completed_by := completed_by sched.

  (** Finally, we introduce the notion of the maximal length of
       (potential) priority inversion at a time instant [t], which is
       defined as the maximum length of nonpreemptive segments among
       all jobs that arrived so far. *)
  Definition max_length_of_priority_inversion (j : Job) (t : instant) :=
    \max_(j_lp <- arrivals_before arr_seq t | (~~ hep_job j_lp j) && (job_cost j_lp > 0))
     (job_max_nonpreemptive_segment j_lp - ε).

  (** Next we prove that a priority inversion of a job is bounded by 
      function [max_length_of_priority_inversion]. *)

  (** Note that any bound on function
      [max_length_of_priority_inversion] will also be a bound on the
      maximal priority inversion. This bound may be different for
      different scheduler and/or task models. Thus, we don't define
      such a bound in this module. *)

  (** Consider any job [j] of [tsk] with positive job cost. *)
  Variable j : Job.
  Hypothesis H_j_arrives : arrives_in arr_seq j.
  Hypothesis H_job_cost_positive : job_cost_positive j.
  
  (** Consider any busy interval prefix <<[t1, t2)>> of job j. *)
  Variable t1 t2 : instant.
  Hypothesis H_busy_interval_prefix:
    busy_interval_prefix arr_seq sched j t1 t2.

  (** * Processor Executes HEP jobs after Preemption Point *)
  (** In this section, we prove that at any time instant after any preemption point
     (inside the busy interval), the processor is always busy scheduling a 
     job with higher or equal priority. *)
  Section PreemptionTimeAndPriorityInversion. 

    (** First, we show that the processor at any preemptive point is always 
        busy scheduling a job with higher or equal priority. *)     
    Section ProcessorBusyWithHEPJobAtPreemptionPoints.

      (** Consider an arbitrary preemption time t ∈ <<[t1,t2)>>. *)
      Variable t : instant.
      Hypothesis H_t_in_busy_interval : t1 <= t < t2.
      Hypothesis H_t_preemption_time : preemption_time sched t.
      
      (** First note since [t] lies inside the busy interval, 
          the processor cannot be idle at time [t]. *)
      Lemma instant_t_is_not_idle:
        ~ is_idle sched t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
~ is_idle sched t
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
~ is_idle sched t
        intros IDLE.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
IDLE: is_idle sched t
False
        by exfalso; apply: not_quiet_implies_not_idle; rt_eauto.
      Qed.
      
      (** Next we consider two cases: (1) when [t] is less than [t2 - 1] and (2) [t] is equal to [t2 - 1]. *)
      Lemma t_lt_t2_or_t_eq_t2:
        t < t2.-1 \/ t = t2.-1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t < t2.-1 \/ t = t2.-1
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t < t2.-1 \/ t = t2.-1
        have TEMP: t <= t2.-1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t <= t2.-1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
TEMP: t <= t2.-1
t < t2.-1 \/ t = t2.-1
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t <= t2.-1 move: (H_t_in_busy_interval) => /andP [GEt LEt].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
t <= t2.-1 
            by rewrite -subn1 leq_subRL_impl // addn1.
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
TEMP: t <= t2.-1
t < t2.-1 \/ t = t2.-1
        rewrite leq_eqVlt in TEMP; move: TEMP => /orP [/eqP EQUALt2m1 | LTt2m1].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
t < t2.-1 \/ t = t2.-1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
t < t2.-1 \/ t = t2.-1
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
t < t2.-1 \/ t = t2.-1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
t < t2.-1 \/ t = t2.-1 right; auto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
t < t2.-1 \/ t = t2.-1
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
t < t2.-1 \/ t = t2.-1 left; auto.
      Qed.
      
      (** In case when [t < t2 - 1], we use the fact that time instant
          [t+1] is not a quiet time. The later implies that there is a
          pending higher-or-equal priority job at time [t]. Thus, the
          assumption that the schedule respects priority policy at
          preemption points implies that the scheduled job must have a
          higher-or-equal priority. *)
      Lemma scheduled_at_preemption_time_implies_higher_or_equal_priority_lt:
        t < t2.-1 -> 
        forall jhp, 
          scheduled_at sched jhp t ->
          hep_job jhp j.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t < t2.-1 ->
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t < t2.-1 ->
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
        intros LTt2m1 jlp Sched_jlp; apply contraT; move => /negP NOTHP; exfalso.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
False
        move: (H_t_in_busy_interval) (H_busy_interval_prefix) => /andP [GEt LEt] [SL [QUIET [NOTQUIET INBI]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
False
        apply NOTQUIET with (t := t.+1).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t1 < t.+1 < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
quiet_time arr_seq sched j t.+1 
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t1 < t.+1 < t2 apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t1 < t.+1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t.+1 < t2
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t1 < t.+1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t.+1 < t2 by apply leq_ltn_trans with t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t.+1 < t2
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
t.+1 < t2 rewrite -subn1 ltn_subRL addnC in LTt2m1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LTt2m1: t + 1 < t2
t.+1 < t2
            by rewrite -[t.+1]addn1.
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
quiet_time arr_seq sched j t.+1
        intros j_hp ARR HP BEF.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
completed_by sched j_hp t.+1
        apply contraT => NCOMP'; exfalso.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
False 
        have PEND : pending sched j_hp t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
pending sched j_hp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
PEND: pending sched j_hp t
False
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
pending sched j_hp t apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
has_arrived j_hp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
~~ completed_by sched j_hp t
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
has_arrived j_hp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
~~ completed_by sched j_hp t by rewrite /has_arrived.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
~~ completed_by sched j_hp t
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
~~ completed_by sched j_hp t by move: NCOMP'; apply contra, completion_monotonic.
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
PEND: pending sched j_hp t
False
        apply H_job_ready in PEND => //; destruct PEND as [j' [ARR' [READY' HEP']]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP': hep_job j' j_hp
False
        have HEP : hep_job j' j by apply (H_priority_is_transitive t j_hp).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j_hp: Job
ARR: arrives_in arr_seq j_hp
HP: hep_job j_hp j
BEF: arrived_before j_hp t.+1
NCOMP': ~~ completed_by sched j_hp t.+1
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP': hep_job j' j_hp
HEP: hep_job j' j
False 
        clear HEP' NCOMP' BEF HP ARR j_hp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
False
        have BACK: backlogged sched j' t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
backlogged sched j' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
BACK: backlogged sched j' t
False
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
backlogged sched j' t apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
~~ scheduled_at sched j' t
          apply/negP; intro SCHED'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
SCHED': scheduled_at sched j' t
False
          move: (ideal_proc_model_is_a_uniprocessor_model jlp j' sched t Sched_jlp SCHED') => EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
SCHED': scheduled_at sched j' t
EQ: jlp = j'
False
          by subst; apply: NOTHP.
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
BACK: backlogged sched j' t
False
        apply NOTHP, (H_priority_is_transitive t j'); last by eapply HEP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
LTt2m1: t < t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
BACK: backlogged sched j' t
hep_job_at t jlp j'
        by eapply H_respects_policy; eauto .
      Qed.

      
      (** In case when [t = t2 - 1], we cannot use the same proof
          since [t+1 = t2], but [t2] is a quiet time. So we do a
          similar case analysis on the fact that [t1 = t ∨ t1 < t]. *)
      Lemma scheduled_at_preemption_time_implies_higher_or_equal_priority_eq:
        t = t2.-1 ->
        forall jhp, 
          scheduled_at sched jhp t ->
          hep_job jhp j.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t = t2.-1 ->
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
t = t2.-1 ->
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
        intros EQUALt2m1 jlp Sched_jlp; apply contraT; move => /negP NOTHP; exfalso.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
False
        move: (H_t_in_busy_interval) (H_busy_interval_prefix) => /andP [GEt LEt] [SL [QUIET [NOTQUIET INBI]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
False
        rewrite leq_eqVlt in GEt; first move: GEt => /orP [/eqP EQUALt1 | LARGERt1].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
EQUALt1: t1 = t
False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
False
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
EQUALt1: t1 = t
False subst t t1; clear LEt SL.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
False 
          have ARR : job_arrival j = t2.-1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
job_arrival j = t2.-1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
False
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
job_arrival j = t2.-1 apply/eqP; rewrite eq_sym eqn_leq.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
t2.-1 <= job_arrival j <= t2.-1 
            destruct t2; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1.-1 i.+1
H_t_preemption_time: preemption_time sched i.+1.-1
H_t_in_busy_interval: i.+1.-1 <= i.+1.-1 < i.+1
jlp: Job
Sched_jlp: scheduled_at sched jlp i.+1.-1
NOTHP: ~ hep_job jlp j
INBI: i.+1.-1 <= job_arrival j < i.+1
NOTQUIET: forall t : nat,
i.+1.-1 < t < i.+1 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j i.+1.-1
i.+1.-1 <= job_arrival j <= i.+1.-1
            rewrite ltnS -pred_Sn in INBI.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1.-1 i.+1
H_t_preemption_time: preemption_time sched i.+1.-1
H_t_in_busy_interval: i.+1.-1 <= i.+1.-1 < i.+1
jlp: Job
Sched_jlp: scheduled_at sched jlp i.+1.-1
NOTHP: ~ hep_job jlp j
NOTQUIET: forall t : nat,
i.+1.-1 < t < i.+1 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j i.+1.-1
INBI: i <= job_arrival j <= i
i.+1.-1 <= job_arrival j <= i.+1.-1
            now rewrite -pred_Sn.
          }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
False
          have PEND: pending sched j t2.-1
            by rewrite -ARR; apply job_pending_at_arrival => //; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
PEND: pending sched j t2.-1
False
          apply H_job_ready in PEND => //; destruct PEND as [jhp [ARRhp [PENDhp HEPhp]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
jhp: Job
ARRhp: arrives_in arr_seq jhp
PENDhp: job_ready sched jhp t2.-1
HEPhp: hep_job jhp j
False
          eapply NOTHP, (H_priority_is_transitive 0); last by apply HEPhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
jhp: Job
ARRhp: arrives_in arr_seq jhp
PENDhp: job_ready sched jhp t2.-1
HEPhp: hep_job jhp j
hep_job_at 0 jlp jhp
          apply (H_respects_policy _ _ t2.-1); auto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
jhp: Job
ARRhp: arrives_in arr_seq jhp
PENDhp: job_ready sched jhp t2.-1
HEPhp: hep_job jhp j
backlogged sched jhp t2.-1
          apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
jhp: Job
ARRhp: arrives_in arr_seq jhp
PENDhp: job_ready sched jhp t2.-1
HEPhp: hep_job jhp j
~~ scheduled_at sched jhp t2.-1
          apply/negP; intros SCHED.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
jhp: Job
ARRhp: arrives_in arr_seq jhp
PENDhp: job_ready sched jhp t2.-1
HEPhp: hep_job jhp j
SCHED: scheduled_at sched jhp t2.-1
False
          move: (ideal_proc_model_is_a_uniprocessor_model _ _ sched _ SCHED Sched_jlp) => EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t2.-1 t2
H_t_preemption_time: preemption_time sched t2.-1
H_t_in_busy_interval: t2.-1 <= t2.-1 < t2
jlp: Job
Sched_jlp: scheduled_at sched jlp t2.-1
NOTHP: ~ hep_job jlp j
INBI: t2.-1 <= job_arrival j < t2
NOTQUIET: forall t : nat,
t2.-1 < t < t2 ->
~ quiet_time arr_seq sched j t
QUIET: quiet_time arr_seq sched j t2.-1
ARR: job_arrival j = t2.-1
jhp: Job
ARRhp: arrives_in arr_seq jhp
PENDhp: job_ready sched jhp t2.-1
HEPhp: hep_job jhp j
SCHED: scheduled_at sched jhp t2.-1
EQ: jhp = jlp
False
          by subst; apply: NOTHP.
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
False        
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
False feed (NOTQUIET t); first by apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
False
          apply NOTQUIET; intros j_hp' IN HP ARR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
completed_by sched j_hp' t
          apply contraT => NOTCOMP'; exfalso.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
False
          have PEND : pending sched j_hp' t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
pending sched j_hp' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
PEND: pending sched j_hp' t
False
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
pending sched j_hp' t apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
has_arrived j_hp' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
~~ completed_by sched j_hp' t
            -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
has_arrived j_hp' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
~~ completed_by sched j_hp' t by rewrite /has_arrived ltnW.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
~~ completed_by sched j_hp' t
            -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
~~ completed_by sched j_hp' t by move: NOTCOMP'; apply contra, completion_monotonic.
          }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
PEND: pending sched j_hp' t
False          
          apply H_job_ready in PEND => //; destruct PEND as [j' [ARR' [READY' HEP']]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP': hep_job j' j_hp'
False
          have HEP : hep_job j' j by apply (H_priority_is_transitive t j_hp').
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j_hp': Job
IN: arrives_in arr_seq j_hp'
HP: hep_job j_hp' j
ARR: arrived_before j_hp' t
NOTCOMP': ~~ completed_by sched j_hp' t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP': hep_job j' j_hp'
HEP: hep_job j' j
False 
          clear ARR HP IN HEP' NOTCOMP' j_hp'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
False
          have BACK: backlogged sched j' t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
backlogged sched j' t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
BACK: backlogged sched j' t
False
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
backlogged sched j' t apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
~~ scheduled_at sched j' t
            apply/negP; intro SCHED'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
SCHED': scheduled_at sched j' t
False
            move: (ideal_proc_model_is_a_uniprocessor_model jlp j' sched t Sched_jlp SCHED') => EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
SCHED': scheduled_at sched j' t
EQ: jlp = j'
False
              by subst; apply: NOTHP.
          }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
BACK: backlogged sched j' t
False
          apply NOTHP, (H_priority_is_transitive t j'); last by eapply HEP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
EQUALt2m1: t = t2.-1
jlp: Job
Sched_jlp: scheduled_at sched jlp t
NOTHP: ~ hep_job jlp j
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: ~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
LARGERt1: t1 < t
j': Job
ARR': arrives_in arr_seq j'
READY': job_ready sched j' t
HEP: hep_job j' j
BACK: backlogged sched j' t
hep_job_at t jlp j'
          by eapply H_respects_policy; eauto .
        }
      Qed.

      (** By combining the above facts we conclude that a job that is
          scheduled at time [t] has higher-or-equal priority. *)
      Corollary scheduled_at_preemption_time_implies_higher_or_equal_priority:
        forall jhp, 
          scheduled_at sched jhp t ->
          hep_job jhp j.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
        move: (H_t_in_busy_interval) (H_busy_interval_prefix) => /andP [GEt LEt] [SL [QUIET [NOTQUIET INBI]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j 
        destruct t_lt_t2_or_t_eq_t2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
H4: t < t2.-1
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
H4: t = t2.-1
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
H4: t < t2.-1
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
H4: t = t2.-1
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j by apply scheduled_at_preemption_time_implies_higher_or_equal_priority_lt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
H4: t = t2.-1
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j 
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
GEt: t1 <= t
LEt: t < t2
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
H4: t = t2.-1
forall jhp : Job,
scheduled_at sched jhp t -> hep_job jhp j by apply scheduled_at_preemption_time_implies_higher_or_equal_priority_eq. 
      Qed.

      (** Since a job that is scheduled at time [t] has higher-or-equal priority, 
          by properties of a busy interval it cannot arrive before time instant [t1]. *)
      Lemma scheduled_at_preemption_time_implies_arrived_between_within_busy_interval:
        forall jhp, 
          scheduled_at sched jhp t ->
          arrived_between jhp t1 t2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
forall jhp : Job,
scheduled_at sched jhp t -> arrived_between jhp t1 t2
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
forall jhp : Job,
scheduled_at sched jhp t -> arrived_between jhp t1 t2
        intros jhp Sched_jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
arrived_between jhp t1 t2
        rename H_work_conserving into WORK, H_jobs_come_from_arrival_sequence into CONS.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
arrived_between jhp t1 t2
        move: (H_busy_interval_prefix) => [SL [QUIET [NOTQUIET INBI]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
arrived_between jhp t1 t2 
        move: (H_t_in_busy_interval) => /andP [GEt LEt].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
arrived_between jhp t1 t2
        have HP := scheduled_at_preemption_time_implies_higher_or_equal_priority _ Sched_jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
arrived_between jhp t1 t2
        move: (Sched_jhp) => PENDING.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: scheduled_at sched jhp t
arrived_between jhp t1 t2
        eapply scheduled_implies_pending in PENDING; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
arrived_between jhp t1 t2
        apply/andP; split; last by apply leq_ltn_trans with (n := t); first by move: PENDING => /andP [ARR _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
t1 <= job_arrival jhp 
        apply contraT; rewrite -ltnNge; intro LT; exfalso.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
False
        feed (QUIET jhp); first by eapply CONS, Sched_jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: hep_job jhp j ->
arrived_before jhp t1 ->
completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
False
        specialize (QUIET HP LT).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
False
        have COMP: job_completed_by jhp t by apply: completion_monotonic QUIET.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
COMP: job_completed_by jhp t
False
        apply completed_implies_not_scheduled in COMP; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
CONS: jobs_come_from_arrival_sequence sched arr_seq
WORK: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
jhp: Job
Sched_jhp: scheduled_at sched jhp t
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
HP: hep_job jhp j
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
COMP: ~~ scheduled_at sched jhp t
False
        by move: COMP => /negP COMP; apply COMP.
      Qed.
      
      (** From the above lemmas we prove that there is a job [jhp] that is (1) scheduled at time [t],
          (2) has higher-or-equal priority, and (3) arrived between [t1] and [t2].   *)
      Corollary not_quiet_implies_exists_scheduled_hp_job_at_preemption_point:
        exists j_hp,
          arrived_between j_hp t1 t2 /\
          hep_job j_hp j /\
          job_scheduled_at j_hp t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
      Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
        move: (H_busy_interval_prefix) => [SL [QUIET [NOTQUIET INBI]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t 
        move: (H_t_in_busy_interval) => /andP [GEt LEt].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
        ideal_proc_model_sched_case_analysis sched t jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
Idle: is_idle sched t
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
Idle: is_idle sched t
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t by exfalso; apply instant_t_is_not_idle. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
        exists jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
arrived_between jhp t1 t2 /\
hep_job jhp j /\ job_scheduled_at jhp t
        repeat split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
arrived_between jhp t1 t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
job_scheduled_at jhp t
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
arrived_between jhp t1 t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
job_scheduled_at jhp t by apply scheduled_at_preemption_time_implies_arrived_between_within_busy_interval.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
job_scheduled_at jhp t
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
job_scheduled_at jhp t by apply scheduled_at_preemption_time_implies_higher_or_equal_priority.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
job_scheduled_at jhp t
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
t: instant
H_t_in_busy_interval: t1 <= t < t2
H_t_preemption_time: preemption_time sched t
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
INBI: t1 <= job_arrival j < t2
GEt: t1 <= t
LEt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
job_scheduled_at jhp t by done.
      Qed.

      
    End ProcessorBusyWithHEPJobAtPreemptionPoints.

    (** ... and the fact that at any time instant after a preemption point the
       processor is always busy with a job with higher or equal priority. *) 
    Lemma not_quiet_implies_exists_scheduled_hp_job_after_preemption_point:
      forall tp t,
        preemption_time sched tp ->
        t1 <= tp < t2 ->
        tp <= t < t2 ->
        exists j_hp,
          arrived_between j_hp t1 t.+1 /\ 
          hep_job j_hp j /\
          job_scheduled_at j_hp t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (tp : instant) (t : nat),
preemption_time sched tp ->
t1 <= tp < t2 ->
tp <= t < t2 ->
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (tp : instant) (t : nat),
preemption_time sched tp ->
t1 <= tp < t2 ->
tp <= t < t2 ->
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
      move => tp t PRPOINT /andP [GEtp LTtp] /andP [LEtp LTt].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
      ideal_proc_model_sched_case_analysis_eq sched t jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
Idle: is_idle sched t
EqIdle: sched t = None
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
      {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
Idle: is_idle sched t
EqIdle: sched t = None
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t apply instant_t_is_not_idle in Idle; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
Idle: is_idle sched t
EqIdle: sched t = None
t1 <= t < t2
        by apply/andP; split; first apply leq_trans with tp. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t 
      exists jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
arrived_between jhp t1 t.+1 /\
hep_job jhp j /\ job_scheduled_at jhp t
      have HP: hep_job jhp j.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
arrived_between jhp t1 t.+1 /\
hep_job jhp j /\ job_scheduled_at jhp t
      {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
hep_job jhp j intros.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
hep_job jhp j
         move:(H_valid_model_with_bounded_nonpreemptive_segments) => [PREE ?].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
hep_job jhp j
        specialize (scheduling_of_any_segment_starts_with_preemption_time arr_seq sched H_sched_valid PREE jhp t Sched_jhp) => SOAS.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
SOAS: exists pt : nat,
  job_arrival jhp <= pt <= t /\
  preemption_time sched pt /\
  (forall t' : nat,
   pt <= t' <= t -> scheduled_at sched jhp t')
hep_job jhp j
        move: SOAS => [prt [/andP [_ LE] [PR SCH]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
hep_job jhp j
        case E:(t1 <= prt).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = true
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = true
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j move: E => /eqP /eqP E; rewrite subn_eq0 in E.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: t1 <= prt
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j
          edestruct not_quiet_implies_exists_scheduled_hp_job_at_preemption_point as [jlp [_ [HEP SCHEDjhp]]]; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: t1 <= prt
t1 <= prt < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: t1 <= prt
jlp: Job
HEP: hep_job jlp j
SCHEDjhp: job_scheduled_at jlp prt
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: t1 <= prt
t1 <= prt < t2 by apply /andP; split; last by apply leq_ltn_trans with t. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: t1 <= prt
jlp: Job
HEP: hep_job jlp j
SCHEDjhp: job_scheduled_at jlp prt
hep_job jhp j
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j
          enough (EQ : jhp = jlp); first by subst.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: t1 <= prt
jlp: Job
HEP: hep_job jlp j
SCHEDjhp: job_scheduled_at jlp prt
jhp = jlp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j
          apply: (ideal_proc_model_is_a_uniprocessor_model _ _ _ prt); eauto;
            by apply SCH; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j
        -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: (t1 <= prt) = false
hep_job jhp j move: E => /eqP /neqP E; rewrite -lt0n subn_gt0 in E.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jhp t'
E: prt < t1
hep_job jhp j
          apply negbNE; apply/negP; intros LP; rename jhp into jlp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jlp: Job
Sched_jhp: scheduled_at sched jlp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jlp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jlp t'
E: prt < t1
LP: ~~ hep_job jlp j
False
          edestruct not_quiet_implies_exists_scheduled_hp_job_at_preemption_point
            as [jhp [_ [HEP SCHEDjhp]]]; [ | apply PRPOINT| ]; first by apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jlp: Job
Sched_jhp: scheduled_at sched jlp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jlp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jlp t'
E: prt < t1
LP: ~~ hep_job jlp j
jhp: Job
HEP: hep_job jhp j
SCHEDjhp: job_scheduled_at jhp tp
False
          move: LP => /negP LP; apply: LP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jlp: Job
Sched_jhp: scheduled_at sched jlp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jlp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jlp t'
E: prt < t1
jhp: Job
HEP: hep_job jhp j
SCHEDjhp: job_scheduled_at jhp tp
hep_job jlp j
          enough (EQ : jhp = jlp); first by subst.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jlp: Job
Sched_jhp: scheduled_at sched jlp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jlp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jlp t'
E: prt < t1
jhp: Job
HEP: hep_job jhp j
SCHEDjhp: job_scheduled_at jhp tp
jhp = jlp
          apply: (ideal_proc_model_is_a_uniprocessor_model jhp _ _ tp); eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jlp: Job
Sched_jhp: scheduled_at sched jlp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jlp (sched t) x)
       x x in F]| <> 0
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
prt: nat
LE: prt <= t
PR: preemption_time sched prt
SCH: forall t' : nat,
prt <= t' <= t -> scheduled_at sched jlp t'
E: prt < t1
jhp: Job
HEP: hep_job jhp j
SCHEDjhp: job_scheduled_at jhp tp
scheduled_at sched jlp tp 
            by apply SCH; apply/andP; split; first apply leq_trans with t1; auto.
      }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
arrived_between jhp t1 t.+1 /\
hep_job jhp j /\ job_scheduled_at jhp t 
      repeat split; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
arrived_between jhp t1 t.+1 
      move: (H_busy_interval_prefix) => [SL [QUIET [NOTQUIET EXj]]]; move: (Sched_jhp) => PENDING.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: scheduled_at sched jhp t
arrived_between jhp t1 t.+1
      eapply scheduled_implies_pending in PENDING; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
arrived_between jhp t1 t.+1
      apply/andP; split; last by apply leq_ltn_trans with (n := t); first by move: PENDING => /andP [ARR _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
t1 <= job_arrival jhp
      apply contraT; rewrite -ltnNge; intro LT; exfalso.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: quiet_time arr_seq sched j t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
False
      feed (QUIET jhp); first by eapply H_jobs_come_from_arrival_sequence, Sched_jhp.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: hep_job jhp j ->
arrived_before jhp t1 ->
completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
False
      specialize (QUIET HP LT).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
False
      have COMP: job_completed_by jhp t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
job_completed_by jhp t
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
COMP: job_completed_by jhp t
False
      {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
job_completed_by jhp t apply: completion_monotonic QUIET; exact: leq_trans LEtp. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
COMP: job_completed_by jhp t
False
      apply completed_implies_not_scheduled in COMP; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
tp: instant
t: nat
PRPOINT: preemption_time sched tp
GEtp: t1 <= tp
LTtp: tp < t2
LEtp: tp <= t
LTt: t < t2
jhp: Job
Sched_jhp: scheduled_at sched jhp t
EqSched_jhp: #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (, scheduled_on jhp (sched t) x)
       x x in F]| <> 0
HP: hep_job jhp j
SL: t1 < t2
QUIET: completed_by sched jhp t1
NOTQUIET: forall t : nat,
t1 < t < t2 ->
~ quiet_time arr_seq sched j t
EXj: t1 <= job_arrival j < t2
PENDING: pending sched jhp t
LT: job_arrival jhp < t1
COMP: ~~ scheduled_at sched jhp t
False
      by move : COMP => /negP COMP; apply : COMP.
    Qed. 
    
    (** Now, suppose there exists some constant K that bounds the distance to 
       a preemption time from the beginning of the busy interval. *)
    Variable K : duration.
    Hypothesis H_preemption_time_exists:
      exists pr_t, preemption_time sched pr_t /\ t1 <= pr_t <= t1 + K.

    (** Then we prove that the processor is always busy with a job with 
       higher-or-equal priority after time instant [t1 + K]. *)
    Lemma not_quiet_implies_exists_scheduled_hp_job:
      forall t,
        t1 + K <= t < t2 ->
        exists j_hp,
          arrived_between j_hp t1 t.+1 /\ 
          hep_job j_hp j /\
          job_scheduled_at j_hp t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
forall t : nat,
t1 + K <= t < t2 ->
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
forall t : nat,
t1 + K <= t < t2 ->
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t 
      move => t /andP [GE LT].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
      move: H_preemption_time_exists => [prt [PR /andP [GEprt LEprt]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
exists j_hp : Job,
  arrived_between j_hp t1 t.+1 /\
  hep_job j_hp j /\ job_scheduled_at j_hp t
      apply not_quiet_implies_exists_scheduled_hp_job_after_preemption_point with (tp := prt); eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
t1 <= prt < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t < t2 
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
t1 <= prt < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t < t2 apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t < t2
        apply leq_ltn_trans with (t1 + K); first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
t1 + K < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t < t2
        by apply leq_ltn_trans with t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t < t2
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t < t2 apply/andP; split; last by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
K: duration
H_preemption_time_exists: exists pr_t : instant,
  preemption_time sched
    pr_t /\
  t1 <= pr_t <= t1 + K
t: nat
GE: t1 + K <= t
LT: t < t2
prt: instant
PR: preemption_time sched prt
GEprt: t1 <= prt
LEprt: prt <= t1 + K
prt <= t
        by apply leq_trans with (t1 + K).
    Qed.
    
  End PreemptionTimeAndPriorityInversion.

  (** * Preemption Time Exists *)
  (** In this section we prove that the function [max_length_of_priority_inversion] 
     indeed upper bounds the priority inversion length. *)
  Section PreemptionTimeExists.

    (** First we prove that if a job with higher-or-equal priority is scheduled at 
       a quiet time [t+1] then this is the first time when this job is scheduled. *)
    Lemma hp_job_not_scheduled_before_quiet_time:
      forall jhp t,
        quiet_time arr_seq sched j t.+1 ->
        job_scheduled_at jhp t.+1 ->
        hep_job jhp j ->
        ~~ job_scheduled_at jhp t.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (jhp : Job) (t : nat),
quiet_time arr_seq sched j t.+1 ->
job_scheduled_at jhp t.+1 ->
hep_job jhp j -> ~~ job_scheduled_at jhp t
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (jhp : Job) (t : nat),
quiet_time arr_seq sched j t.+1 ->
job_scheduled_at jhp t.+1 ->
hep_job jhp j -> ~~ job_scheduled_at jhp t
      intros jhp t QT SCHED1 HP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: quiet_time arr_seq sched j t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
~~ job_scheduled_at jhp t            
      apply/negP; intros SCHED2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: quiet_time arr_seq sched j t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
      specialize (QT jhp).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: arrives_in arr_seq jhp ->
hep_job jhp j ->
arrived_before jhp t.+1 ->
completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
      feed_n 3 QT; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: arrived_before jhp t.+1 ->
completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
arrived_before jhp t.+1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: arrived_before jhp t.+1 ->
completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
arrived_before jhp t.+1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False have MATE: jobs_must_arrive_to_execute sched by rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: arrived_before jhp t.+1 ->
completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
MATE: jobs_must_arrive_to_execute sched
arrived_before jhp t.+1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
        have HA: has_arrived jhp t by apply MATE.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: arrived_before jhp t.+1 ->
completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
MATE: jobs_must_arrive_to_execute sched
HA: has_arrived jhp t
arrived_before jhp t.+1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
        by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: completed_by sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
      apply completed_implies_not_scheduled in QT; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
t: nat
QT: ~~ scheduled_at sched jhp t.+1
SCHED1: job_scheduled_at jhp t.+1
HP: hep_job jhp j
SCHED2: job_scheduled_at jhp t
False
      by move: QT => /negP NSCHED; apply: NSCHED.
    Qed.

    (** Also, we show that lower-priority jobs that are scheduled inside the
       busy-interval prefix <<[t1,t2)>> must arrive before that interval. *)
    Lemma low_priority_job_arrives_before_busy_interval_prefix:
      forall jlp t,
        t1 <= t < t2 ->
        job_scheduled_at jlp t ->
        ~~ hep_job jlp j ->
        job_arrival jlp < t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (jlp : Job) (t : nat),
t1 <= t < t2 ->
job_scheduled_at jlp t ->
~~ hep_job jlp j -> job_arrival jlp < t1
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (jlp : Job) (t : nat),
t1 <= t < t2 ->
job_scheduled_at jlp t ->
~~ hep_job jlp j -> job_arrival jlp < t1
      move => jlp t /andP [GE LT] SCHED LP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
job_arrival jlp < t1
      move: (H_busy_interval_prefix) => [NEM [QT [NQT HPJ]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
job_arrival jlp < t1
      apply negbNE; apply/negP; intros ARR; rewrite -leqNgt in ARR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
False
      rewrite /job_scheduled_at in SCHED.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
False
      move:(H_valid_model_with_bounded_nonpreemptive_segments) => [PREE ?].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
False
      specialize (scheduling_of_any_segment_starts_with_preemption_time arr_seq sched H_sched_valid PREE jlp t SCHED) => SCH.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
SCH: exists pt : nat,
  job_arrival jlp <= pt <= t /\
  preemption_time sched pt /\
  (forall t' : nat,
   pt <= t' <= t -> scheduled_at sched jlp t')
False
      move: SCH => [pt [/andP [NEQ1 NEQ2] [PT FA]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
False
      have NEQ: t1 <= pt < t2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
t1 <= pt < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
NEQ: t1 <= pt < t2
False
      {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
t1 <= pt < t2 apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
t1 <= pt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
pt < t2
        apply leq_trans with (job_arrival jlp); by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
pt < t2
        apply leq_ltn_trans with t; by done. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
NEQ: t1 <= pt < t2
False
      have LL:= not_quiet_implies_exists_scheduled_hp_job_at_preemption_point pt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
NEQ: t1 <= pt < t2
LL: t1 <= pt < t2 ->
preemption_time sched pt ->
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
False
      feed_n 2 LL; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
NEQ: t1 <= pt < t2
LL: exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
False
      move: LL => [jhp [ARRjhp [HP SCHEDhp]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
NEQ: t1 <= pt < t2
jhp: Job
ARRjhp: arrived_between jhp t1 t2
HP: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
False
      feed (FA pt); first (by apply/andP; split).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
LP: ~~ hep_job jlp j
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: scheduled_at sched jlp pt
NEQ: t1 <= pt < t2
jhp: Job
ARRjhp: arrived_between jhp t1 t2
HP: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
False 
      move: LP => /negP LP; apply: LP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
GE: t1 <= t
LT: t < t2
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
ARR: t1 <= job_arrival jlp
SCHED: scheduled_at sched jlp t
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQ1: job_arrival jlp <= pt
NEQ2: pt <= t
PT: preemption_time sched pt
FA: scheduled_at sched jlp pt
NEQ: t1 <= pt < t2
jhp: Job
ARRjhp: arrived_between jhp t1 t2
HP: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
hep_job jlp j
      by have ->: jlp = jhp by eapply ideal_proc_model_is_a_uniprocessor_model; eauto.
    Qed.
     
    (** Moreover, we show that lower-priority jobs that are scheduled
        inside the busy-interval prefix <<[t1,t2)>> must be scheduled
        before that interval. *)
    Lemma low_priority_job_scheduled_before_busy_interval_prefix:
      forall jlp t,
        t1 <= t < t2 ->
        job_scheduled_at jlp t ->
        ~~ hep_job jlp j ->
        exists t', t' < t1 /\ job_scheduled_at jlp t'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (jlp : Job) (t : nat),
t1 <= t < t2 ->
job_scheduled_at jlp t ->
~~ hep_job jlp j ->
exists t' : nat, t' < t1 /\ job_scheduled_at jlp t'
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
forall (jlp : Job) (t : nat),
t1 <= t < t2 ->
job_scheduled_at jlp t ->
~~ hep_job jlp j ->
exists t' : nat, t' < t1 /\ job_scheduled_at jlp t'
      move => jlp t NEQ SCHED LP; move: (NEQ) => /andP [GE LT].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
exists t' : nat, t' < t1 /\ job_scheduled_at jlp t'
      have ARR := low_priority_job_arrives_before_busy_interval_prefix _ _ NEQ SCHED LP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
exists t' : nat, t' < t1 /\ job_scheduled_at jlp t' 
      exists t1.-1; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
t1.-1 < t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
job_scheduled_at jlp t1.-1
      {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
t1.-1 < t1 by rewrite prednK; last apply leq_ltn_trans with (job_arrival jlp). }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
job_scheduled_at jlp t1.-1 
      move: (H_busy_interval_prefix) => [NEM [QT [NQT HPJ]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
job_scheduled_at jlp t1.-1
      move:(H_valid_model_with_bounded_nonpreemptive_segments) => [PREE ?].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
job_scheduled_at jlp t1.-1
      specialize (scheduling_of_any_segment_starts_with_preemption_time arr_seq sched H_sched_valid PREE jlp t SCHED) => SCHEDST.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
SCHEDST: exists pt : nat,
  job_arrival jlp <= pt <= t /\
  preemption_time sched pt /\
  (forall t' : nat,
   pt <= t' <= t ->
   scheduled_at sched jlp t')
job_scheduled_at jlp t1.-1
      move: SCHEDST => [pt [NEQpt [PT SCHEDc]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
job_scheduled_at jlp t1.-1
      have LT2: pt < t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
pt < t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
job_scheduled_at jlp t1.-1
      {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
pt < t1 rewrite ltnNge; apply/negP; intros CONTR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
False
        have NQSCHED := not_quiet_implies_exists_scheduled_hp_job_at_preemption_point pt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
NQSCHED: t1 <= pt < t2 ->
preemption_time sched pt ->
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
False
        feed_n 2 NQSCHED; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
NQSCHED: t1 <= pt < t2 ->
preemption_time sched pt ->
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
t1 <= pt < t2
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
NQSCHED: exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
False
        {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
NQSCHED: t1 <= pt < t2 ->
preemption_time sched pt ->
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
t1 <= pt < t2 apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
NQSCHED: t1 <= pt < t2 ->
preemption_time sched pt ->
exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
pt < t2
            by apply leq_ltn_trans with t; move: NEQpt => /andP [_ T].
        }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
NQSCHED: exists j_hp : Job,
  arrived_between j_hp t1 t2 /\
  hep_job j_hp j /\ job_scheduled_at j_hp pt
False move: NQSCHED => [jhp [ARRhp [HPhp SCHEDhp]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
CONTR: t1 <= pt
jhp: Job
ARRhp: arrived_between jhp t1 t2
HPhp: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
False
        specialize (SCHEDc pt).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: pt <= pt <= t -> scheduled_at sched jlp pt
CONTR: t1 <= pt
jhp: Job
ARRhp: arrived_between jhp t1 t2
HPhp: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
False
        feed SCHEDc; first by apply/andP; split; last move: NEQpt => /andP [_ T].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: scheduled_at sched jlp pt
CONTR: t1 <= pt
jhp: Job
ARRhp: arrived_between jhp t1 t2
HPhp: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
False 
        move: LP => /negP LP; apply: LP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: scheduled_at sched jlp pt
CONTR: t1 <= pt
jhp: Job
ARRhp: arrived_between jhp t1 t2
HPhp: hep_job jhp j
SCHEDhp: job_scheduled_at jhp pt
hep_job jlp j
          by have ->: jlp = jhp by eapply ideal_proc_model_is_a_uniprocessor_model; eauto.
      }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
job_scheduled_at jlp t1.-1
      apply SCHEDc; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
pt <= t1.-1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
t1.-1 <= t
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
pt <= t1.-1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
t1.-1 <= t by rewrite -add1n in LT2; apply leq_subRL_impl in LT2; rewrite subn1 in LT2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
t1.-1 <= t
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
t: nat
NEQ: t1 <= t < t2
SCHED: job_scheduled_at jlp t
LP: ~~ hep_job jlp j
GE: t1 <= t
LT: t < t2
ARR: job_arrival jlp < t1
NEM: t1 < t2
QT: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
PREE: valid_preemption_model arr_seq sched
_b_: model_with_bounded_nonpreemptive_segments
  arr_seq
pt: nat
NEQpt: job_arrival jlp <= pt <= t
PT: preemption_time sched pt
SCHEDc: forall t' : nat,
pt <= t' <= t -> scheduled_at sched jlp t'
LT2: pt < t1
t1.-1 <= t by apply leq_trans with t1; first apply leq_pred. 
    Qed.
    
    (** Thus, there must be a preemption time in the interval [t1, t1
        + max_priority_inversion t1]. That is, if a job with
        higher-or-equal priority is scheduled at time instant t1, then
        t1 is a preemption time. Otherwise, if a job with lower
        priority is scheduled at time t1, then this jobs also should
        be scheduled before the beginning of the busy interval. So,
        the next preemption time will be no more than
        [max_priority_inversion t1] time units later. *)

    (** We proceed by doing a case analysis. *)
    Section CaseAnalysis.

      (** (1) Case when the schedule is idle at time [t1]. *)
      Section Case1.

        (** Assume that the schedule is idle at time [t1]. *)
        Hypothesis H_is_idle : is_idle sched t1. 

        (** Then time instant [t1] is a preemption time. *)
        Lemma preemption_time_exists_case1: 
          exists pr_t,
            preemption_time sched pr_t /\
            t1 <= pr_t <= t1 + max_length_of_priority_inversion j t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          set (service := service sched).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move: (H_valid_model_with_bounded_nonpreemptive_segments) => CORR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move: (H_busy_interval_prefix) => [NEM [QT1 [NQT HPJ]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          exists t1; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
preemption_time sched t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
t1 <= t1 <= t1 + max_length_of_priority_inversion j t1
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
preemption_time sched t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
t1 <= t1 <= t1 + max_length_of_priority_inversion j t1 by rewrite /preemption_time; move: H_is_idle => /eqP ->.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
t1 <= t1 <= t1 + max_length_of_priority_inversion j t1
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
H_is_idle: is_idle sched t1
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
t1 <= t1 <= t1 + max_length_of_priority_inversion j t1 by apply/andP; split; last rewrite leq_addr. 
        Qed.
        
      End Case1.

      (** (2) Case when a job with higher-or-equal priority is scheduled at time [t1]. *)
      Section Case2.

        (** Assume that a job [jhp] with higher-or-equal priority is scheduled at time [t1]. *)
        Variable jhp : Job.
        Hypothesis H_jhp_is_scheduled : scheduled_at sched jhp t1. 
        Hypothesis H_jhp_hep_priority : hep_job jhp j.

        (** Then time instant [t1] is a preemption time. *)
        Lemma preemption_time_exists_case2: 
          exists pr_t,
            preemption_time sched pr_t /\
            t1 <= pr_t <= t1 + max_length_of_priority_inversion j t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          set (service := service sched).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move :  (H_valid_model_with_bounded_nonpreemptive_segments) =>  [VALID BOUNDED].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move: (H_valid_model_with_bounded_nonpreemptive_segments) => CORR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move: (H_busy_interval_prefix) => [NEM [QT1 [NQT HPJ]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          exists t1; split; last first.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
t1 <= t1 <= t1 + max_length_of_priority_inversion j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
preemption_time sched t1
          apply/andP; split; [by done | by rewrite leq_addr].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp t1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
preemption_time sched t1
          destruct t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j 0 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp 0
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: 0 < t2
QT1: quiet_time arr_seq sched j 0
NQT: forall t : nat,
0 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: 0 <= job_arrival j < t2
preemption_time sched 0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp i.+1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: i.+1 < t2
QT1: quiet_time arr_seq sched j i.+1
NQT: forall t : nat,
i.+1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: i < job_arrival j < t2
preemption_time sched i.+1
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j 0 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp 0
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: 0 < t2
QT1: quiet_time arr_seq sched j 0
NQT: forall t : nat,
0 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: 0 <= job_arrival j < t2
preemption_time sched 0
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp i.+1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: i.+1 < t2
QT1: quiet_time arr_seq sched j i.+1
NQT: forall t : nat,
i.+1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: i < job_arrival j < t2
preemption_time sched i.+1 by eapply zero_is_pt; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp i.+1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: i.+1 < t2
QT1: quiet_time arr_seq sched j i.+1
NQT: forall t : nat,
i.+1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: i < job_arrival j < t2
preemption_time sched i.+1
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp i.+1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: i.+1 < t2
QT1: quiet_time arr_seq sched j i.+1
NQT: forall t : nat,
i.+1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: i < job_arrival j < t2
preemption_time sched i.+1 apply: first_moment_is_pt H_jhp_is_scheduled; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
i: nat
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j i.+1 t2
jhp: Job
H_jhp_is_scheduled: scheduled_at sched jhp i.+1
H_jhp_hep_priority: hep_job jhp j
service:= service.service sched: Job -> instant -> nat
VALID: valid_preemption_model arr_seq sched
BOUNDED: model_with_bounded_nonpreemptive_segments
  arr_seq
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: i.+1 < t2
QT1: quiet_time arr_seq sched j i.+1
NQT: forall t : nat,
i.+1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: i < job_arrival j < t2
~~ scheduled_at sched jhp i
            by eapply hp_job_not_scheduled_before_quiet_time; try by done.
        Qed.
          
      End Case2.

      (** (3) Case when a job with lower priority is scheduled at time [t1]. *)
      Section Case3.

        (** Assume that a job [jhp] with lower priority is scheduled at time [t1]. *)
        Variable jlp : Job.
        Hypothesis H_jlp_is_scheduled : scheduled_at sched jlp t1.
        Hypothesis H_jlp_low_priority : ~~ hep_job jlp j.

        (** To prove the lemma in this case we need a few auxiliary
            facts about the first preemption point of job [jlp]. *)
        Section FirstPreemptionPointOfjlp.

          (** Let's denote the progress of job [jlp] at time [t1] as [progr_t1]. *)
          Let progr_t1 := service sched jlp t1. 

          (** Consider the first preemption point of job [jlp] after [progr_t1]. *)
          Variable fpt : instant.
          Hypothesis H_fpt_is_preemptio_point : job_preemptable jlp (progr_t1 + fpt).
          Hypothesis H_fpt_is_first_preemption_point:
            forall ρ,
              progr_t1 <= ρ <= progr_t1 + (job_max_nonpreemptive_segment jlp - ε) -> 
              job_preemptable jlp ρ ->
              service sched jlp t1 + fpt <= ρ.

          (** For convenience we also assume the following inequality holds. *)
          Hypothesis H_progr_le_max_nonp_segment:
            progr_t1 <= progr_t1 + fpt <= progr_t1 + (job_max_nonpreemptive_segment jlp - ε).

          (** First we show that [fpt] is indeed the first preemption point after [progr_t1]. *)
          Lemma no_intermediate_preemption_point:
            forall ρ,
              progr_t1 <= ρ < progr_t1 + fpt ->
              ~~ job_preemptable jlp ρ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
forall ρ : nat,
progr_t1 <= ρ < progr_t1 + fpt ->
~~ job_preemptable jlp ρ 
          Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
forall ρ : nat,
progr_t1 <= ρ < progr_t1 + fpt ->
~~ job_preemptable jlp ρ
            move => prog /andP [GE LT].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
~~ job_preemptable jlp prog
            apply/negP; intros PPJ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
False
            move: H_fpt_is_first_preemption_point => K; specialize (K prog).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
False 
            feed_n 2 K; first (apply/andP; split); try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: service sched jlp t1 + fpt <= prog
False
            apply leq_trans with (service sched jlp t1 + fpt).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
prog <= service sched jlp t1 + fpt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
service sched jlp t1 + fpt <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: service sched jlp t1 + fpt <= prog
False
            +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
prog <= service sched jlp t1 + fpt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
service sched jlp t1 + fpt <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: service sched jlp t1 + fpt <= prog
False by apply ltnW.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
service sched jlp t1 + fpt <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: service sched jlp t1 + fpt <= prog
False 
            +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: progr_t1 <= prog <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp prog ->
service sched jlp t1 + fpt <= prog
service sched jlp t1 + fpt <=
progr_t1 + (job_max_nonpreemptive_segment jlp - ε)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: service sched jlp t1 + fpt <= prog
False by move: H_progr_le_max_nonp_segment => /andP [_ LL].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
prog: nat
GE: progr_t1 <= prog
LT: prog < progr_t1 + fpt
PPJ: job_preemptable jlp prog
K: service sched jlp t1 + fpt <= prog
False
                by move: K; rewrite leqNgt; move => /negP NLT; apply: NLT.
          Qed.

          (** Thanks to the fact that the scheduler respects the notion of preemption points
              we show that [jlp] is continuously scheduled in time interval <<[t1, t1 + fpt)>>. *)
          Lemma continuously_scheduled_between_preemption_points:
            forall t',
              t1 <= t' < t1 + fpt ->
              job_scheduled_at jlp t'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
forall t' : nat,
t1 <= t' < t1 + fpt -> job_scheduled_at jlp t'
          Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
forall t' : nat,
t1 <= t' < t1 + fpt -> job_scheduled_at jlp t'
             move: (H_valid_model_with_bounded_nonpreemptive_segments) => CORR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
forall t' : nat,
t1 <= t' < t1 + fpt -> job_scheduled_at jlp t'
             move: (H_jlp_is_scheduled) => ARRs; apply H_jobs_come_from_arrival_sequence in ARRs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
forall t' : nat,
t1 <= t' < t1 + fpt -> job_scheduled_at jlp t'             
            move => t' /andP [GE LT].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
t': nat
GE: t1 <= t'
LT: t' < t1 + fpt
job_scheduled_at jlp t' 
              have Fact: exists Δ, t' = t1 + Δ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
t': nat
GE: t1 <= t'
LT: t' < t1 + fpt
exists Δ : nat, t' = t1 + Δ
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
t': nat
GE: t1 <= t'
LT: t' < t1 + fpt
Fact: exists Δ : nat, t' = t1 + Δ
job_scheduled_at jlp t'
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
t': nat
GE: t1 <= t'
LT: t' < t1 + fpt
exists Δ : nat, t' = t1 + Δ by exists (t' - t1); apply/eqP; rewrite eq_sym; apply/eqP; rewrite subnKC. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
t': nat
GE: t1 <= t'
LT: t' < t1 + fpt
Fact: exists Δ : nat, t' = t1 + Δ
job_scheduled_at jlp t'
              move: Fact => [Δ EQ]; subst t'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
job_scheduled_at jlp (t1 + Δ)
              have NPPJ := @no_intermediate_preemption_point (@service _ _ sched jlp (t1 + Δ)).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
NPPJ: progr_t1 <= 
service sched jlp (t1 + Δ) < 
progr_t1 + fpt ->
~~
job_preemptable jlp
  (service sched jlp (t1 + Δ))
job_scheduled_at jlp (t1 + Δ)
              apply proj1 in CORR; specialize (CORR jlp ARRs).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: job_cannot_become_nonpreemptive_before_execution
  jlp /\
job_cannot_be_nonpreemptive_after_completion
  jlp /\
not_preemptive_implies_scheduled sched jlp /\
execution_starts_with_preemption_point sched
  jlp
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
NPPJ: progr_t1 <= 
service sched jlp (t1 + Δ) < 
progr_t1 + fpt ->
~~
job_preemptable jlp
  (service sched jlp (t1 + Δ))
job_scheduled_at jlp (t1 + Δ)
              move: CORR => [_ [_ [T _] ]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
NPPJ: progr_t1 <= 
service sched jlp (t1 + Δ) < 
progr_t1 + fpt ->
~~
job_preemptable jlp
  (service sched jlp (t1 + Δ))
T: not_preemptive_implies_scheduled sched jlp
job_scheduled_at jlp (t1 + Δ)
              apply T; apply: NPPJ; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
progr_t1 <= service sched jlp (t1 + Δ)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
service sched jlp (t1 + Δ) < progr_t1 + fpt
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
progr_t1 <= service sched jlp (t1 + Δ) by apply service_monotonic; rewrite leq_addr. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
service sched jlp (t1 + Δ) < progr_t1 + fpt
              rewrite /service  -(service_during_cat _ _ _ t1).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
service_during sched jlp 0 t1 +
service_during sched jlp t1 (t1 + Δ) < progr_t1 + fpt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
0 <= t1 <= t1 + Δ
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
service_during sched jlp 0 t1 +
service_during sched jlp t1 (t1 + Δ) < progr_t1 + fpt rewrite ltn_add2l; rewrite ltn_add2l in LT.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
LT: Δ < fpt
service_during sched jlp t1 (t1 + Δ) < fpt
                apply leq_ltn_trans with Δ; last by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
LT: Δ < fpt
service_during sched jlp t1 (t1 + Δ) <= Δ
                rewrite -{2}(sum_of_ones t1 Δ).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
LT: Δ < fpt
service_during sched jlp t1 (t1 + Δ) <=
\sum_(t1 <= x < t1 + Δ) 1
                rewrite leq_sum //; intros t _.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
LT: Δ < fpt
t: nat
service_at sched jlp t <= 1
                apply service_at_most_one.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
LT: Δ < fpt
t: nat
unit_service_proc_model (processor_state Job)
                  by apply ideal_proc_model_provides_unit_service.
              }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
0 <= t1 <= t1 + Δ 
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
Δ: nat
LT: t1 + Δ < t1 + fpt
GE: t1 <= t1 + Δ
T: not_preemptive_implies_scheduled sched jlp
0 <= t1 <= t1 + Δ by apply/andP; split; [done | rewrite leq_addr]. } 
          Qed.
          
          (** Thus, job [jlp] reaches its preemption point at time instant [t1 + fpt], 
              which implies that time instant [t1 + fpt] is a preemption time. *)
          Lemma first_preemption_time: 
            preemption_time sched (t1 + fpt).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
preemption_time sched (t1 + fpt)
          Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
preemption_time sched (t1 + fpt)
            rewrite /preemption_time.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
match sched (t1 + fpt) with
| Some j =>
    job_preemptable j (service sched j (t1 + fpt))
| None => true
end
            move: (H_valid_model_with_bounded_nonpreemptive_segments) => CORR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
match sched (t1 + fpt) with
| Some j =>
    job_preemptable j (service sched j (t1 + fpt))
| None => true
end
            ideal_proc_model_sched_case_analysis_eq sched (t1 + fpt) s'; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': #|[pred x |
    let
    'FiniteQuant.Quantified F :=
     FiniteQuant.ex (T:=Core)
       (,
          scheduled_on s'
           (sched (t1 + fpt)) x) x x in F]| <>
0
match sched (t1 + fpt) with
| Some j =>
    job_preemptable j (service sched j (t1 + fpt))
| None => true
end
            clear EqSched_s'; move: (Sched_s'); rewrite scheduled_at_def;
              move => /eqP EqSched_s'; rewrite EqSched_s'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
job_preemptable s' (service sched s' (t1 + fpt))
            destruct (jlp == s') eqn: EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = true
job_preemptable s' (service sched s' (t1 + fpt))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt))
            -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = true
job_preemptable s' (service sched s' (t1 + fpt))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt)) move: EQ => /eqP EQ; subst s'.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
job_preemptable jlp (service sched jlp (t1 + fpt))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt))
              rewrite /service -(service_during_cat _ _ _ t1); last first.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
0 <= t1 <= t1 + fpt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
job_preemptable jlp
  (service_during sched jlp 0 t1 +
   service_during sched jlp t1 (t1 + fpt))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt))
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
0 <= t1 <= t1 + fpt by apply/andP; split; last rewrite leq_addr. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
job_preemptable jlp
  (service_during sched jlp 0 t1 +
   service_during sched jlp t1 (t1 + fpt))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt))              
              have ->: service_during sched jlp t1 (t1 + fpt) = fpt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
service_during sched jlp t1 (t1 + fpt) = fpt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
job_preemptable jlp
  (service_during sched jlp 0 t1 + fpt)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt))
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
service_during sched jlp t1 (t1 + fpt) = fpt rewrite -{2}(sum_of_ones t1 fpt) /service_during.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t =
\sum_(t1 <= x < t1 + fpt) 1
                apply/eqP; rewrite eqn_leq //; apply/andP; split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t <=
\sum_(t1 <= x < t1 + fpt) 1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= x < t1 + fpt) 1 <=
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t
                +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t <=
\sum_(t1 <= x < t1 + fpt) 1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= x < t1 + fpt) 1 <=
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t rewrite leq_sum //; intros t _.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
t: nat
service_at sched jlp t <= 1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= x < t1 + fpt) 1 <=
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t
                  apply service_at_most_one.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
t: nat
unit_service_proc_model (processor_state Job)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= x < t1 + fpt) 1 <=
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t
                    by apply ideal_proc_model_provides_unit_service.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= x < t1 + fpt) 1 <=
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t
                +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= x < t1 + fpt) 1 <=
\sum_(t1 <= t < t1 + fpt) service_at sched jlp t rewrite big_nat_cond [in X in _ <= X]big_nat_cond.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
\sum_(t1 <= i < t1 + fpt | (t1 <= i < t1 + fpt) &&
                           true) 1 <=
\sum_(t1 <= i < t1 + fpt | (t1 <= i < t1 + fpt) &&
                           true)
   service_at sched jlp i
                  rewrite leq_sum //.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
forall i : nat,
(t1 <= i < t1 + fpt) && true ->
0 < service_at sched jlp i
                  move => x /andP [HYP _].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
x: nat
HYP: t1 <= x < t1 + fpt
0 < service_at sched jlp x
                  rewrite service_at_def lt0b -scheduled_at_def.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
x: nat
HYP: t1 <= x < t1 + fpt
scheduled_at sched jlp x
                    by apply continuously_scheduled_between_preemption_points.
              }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
EqSched_s': sched (t1 + fpt) = Some jlp
Sched_s': scheduled_at sched jlp (t1 + fpt)
job_preemptable jlp
  (service_during sched jlp 0 t1 + fpt)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt)) by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt))
            -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + fpt)) case: (posnP fpt) => [ZERO|POS].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
ZERO: fpt = 0
job_preemptable s' (service sched s' (t1 + fpt))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
job_preemptable s' (service sched s' (t1 + fpt))
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
ZERO: fpt = 0
job_preemptable s' (service sched s' (t1 + fpt)) subst fpt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + 0 <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
0 <= ρ
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + 0)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
EqSched_s': sched (t1 + 0) = Some s'
Sched_s': scheduled_at sched s' (t1 + 0)
EQ: (jlp == s') = false
job_preemptable s' (service sched s' (t1 + 0))
                exfalso; move: EQ => /negP EQ; apply: EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + 0 <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
0 <= ρ
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + 0)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
EqSched_s': sched (t1 + 0) = Some s'
Sched_s': scheduled_at sched s' (t1 + 0)
jlp == s'
                move: H_jlp_is_scheduled; rewrite scheduled_at_def; move => /eqP SCHED2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + 0 <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
0 <= ρ
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + 0)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
EqSched_s': sched (t1 + 0) = Some s'
Sched_s': scheduled_at sched s' (t1 + 0)
SCHED2: sched t1 = Some jlp
jlp == s'
                rewrite addn0 in EqSched_s'; rewrite EqSched_s' in SCHED2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + 0 <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
0 <= ρ
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + 0)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + 0)
EqSched_s': sched t1 = Some s'
SCHED2: Some s' = Some jlp
jlp == s'
                  by inversion SCHED2.
              }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
job_preemptable s' (service sched s' (t1 + fpt))
              {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
job_preemptable s' (service sched s' (t1 + fpt)) have EX: exists sm, sm.+1 = fpt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
exists sm : nat, sm.+1 = fpt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
EX: exists sm : nat, sm.+1 = fpt
job_preemptable s' (service sched s' (t1 + fpt))
                {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
exists sm : nat, sm.+1 = fpt exists fpt.-1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
fpt.-1.+1 = fpt lia. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
EX: exists sm : nat, sm.+1 = fpt
job_preemptable s' (service sched s' (t1 + fpt))
                destruct EX as [sm EQ2].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
job_preemptable s' (service sched s' (t1 + fpt)) rewrite -EQ2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
job_preemptable s' (service sched s' (t1 + sm.+1))
                rewrite addnS.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
job_preemptable s' (service sched s' (t1 + sm).+1)
                move: ((proj1 CORR) s' (H_jobs_come_from_arrival_sequence _ _ Sched_s')) => T.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
T: job_cannot_become_nonpreemptive_before_execution
  s' /\
job_cannot_be_nonpreemptive_after_completion s' /\
not_preemptive_implies_scheduled sched s' /\
execution_starts_with_preemption_point sched s'
job_preemptable s' (service sched s' (t1 + sm).+1)
                apply T; clear T.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
~~ scheduled_at sched s' (t1 + sm)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
scheduled_at sched s' (t1 + sm).+1 apply /negP; intros CONTR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
CONTR: scheduled_at sched s' (t1 + sm)
False
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
scheduled_at sched s' (t1 + sm).+1 
                move: EQ => /negP EQ; apply: EQ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
CONTR: scheduled_at sched s' (t1 + sm)
jlp == s'
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
scheduled_at sched s' (t1 + sm).+1            
                move: (continuously_scheduled_between_preemption_points (t1 + sm)) => SCHEDs0.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
CONTR: scheduled_at sched s' (t1 + sm)
SCHEDs0: t1 <= t1 + sm < t1 + fpt ->
job_scheduled_at jlp (t1 + sm)
jlp == s'
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
scheduled_at sched s' (t1 + sm).+1
                feed SCHEDs0; first by apply/andP; split; [rewrite leq_addr | rewrite -EQ2 addnS].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
CONTR: scheduled_at sched s' (t1 + sm)
SCHEDs0: job_scheduled_at jlp (t1 + sm)
jlp == s'
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
scheduled_at sched s' (t1 + sm).+1
                apply/eqP; eapply ideal_proc_model_is_a_uniprocessor_model; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
s': Job
Sched_s': scheduled_at sched s' (t1 + fpt)
EqSched_s': sched (t1 + fpt) = Some s'
EQ: (jlp == s') = false
POS: 0 < fpt
sm: nat
EQ2: sm.+1 = fpt
scheduled_at sched s' (t1 + sm).+1
                  by rewrite -addnS EQ2. 
              }
          Qed.

          (** And since [fpt <= max_length_of_priority_inversion j t1], 
              [t1 <= t1 + fpt <= t1 + max_length_of_priority_inversion j t1]. *) 
          Lemma preemption_time_le_max_len_of_priority_inversion: 
            t1 <= t1 + fpt <= t1 + max_length_of_priority_inversion j t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
t1 <= t1 + fpt <=
t1 + max_length_of_priority_inversion j t1
          Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
t1 <= t1 + fpt <=
t1 + max_length_of_priority_inversion j t1
            move: (H_jlp_is_scheduled) => ARRs; apply H_jobs_come_from_arrival_sequence in ARRs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
t1 <= t1 + fpt <=
t1 + max_length_of_priority_inversion j t1
            move: H_progr_le_max_nonp_segment => /andP [GE LE].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
t1 <= t1 + fpt <=
t1 + max_length_of_priority_inversion j t1
            apply/andP; split; first by rewrite leq_addr.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
t1 + fpt <= t1 + max_length_of_priority_inversion j t1
            rewrite leq_add2l.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
fpt <= max_length_of_priority_inversion j t1
            unfold max_length_of_priority_inversion.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
fpt <=
\max_(j_lp <- arrivals_before arr_seq t1 | ~~
                                           hep_job
                                             j_lp j &&
                                           (0 <
                                            job_cost
                                              j_lp))
   (job_max_nonpreemptive_segment j_lp - ε)
            rewrite (big_rem jlp) //=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
fpt <=
maxn
  (if ~~ hep_job jlp j && (0 < job_cost jlp)
   then job_max_nonpreemptive_segment jlp - ε
   else 0)
  (\max_(y <- rem (T:=Job) jlp
                (arrivals_before arr_seq t1) | ~~
                                               hep_job
                                                 y j &&
                                               (0 <
                                                job_cost
                                                 y))
      (job_max_nonpreemptive_segment y - ε))
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
jlp \in arrivals_before arr_seq t1
            {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
fpt <=
maxn
  (if ~~ hep_job jlp j && (0 < job_cost jlp)
   then job_max_nonpreemptive_segment jlp - ε
   else 0)
  (\max_(y <- rem (T:=Job) jlp
                (arrivals_before arr_seq t1) | ~~
                                               hep_job
                                                 y j &&
                                               (0 <
                                                job_cost
                                                 y))
      (job_max_nonpreemptive_segment y - ε)) rewrite H_jlp_low_priority //=.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
fpt <=
maxn
  (if 0 < job_cost jlp
   then job_max_nonpreemptive_segment jlp - ε
   else 0)
  (\max_(y <- rem (T:=Job) jlp
                (arrivals_before arr_seq t1) | ~~
                                               hep_job
                                                 y j &&
                                               (0 <
                                                job_cost
                                                 y))
      (job_max_nonpreemptive_segment y - ε))
              have NZ: service sched jlp t1 < job_cost jlp
                by apply: service_lt_cost; rt_eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
NZ: service sched jlp t1 < job_cost jlp
fpt <=
maxn
  (if 0 < job_cost jlp
   then job_max_nonpreemptive_segment jlp - ε
   else 0)
  (\max_(y <- rem (T:=Job) jlp
                (arrivals_before arr_seq t1) | ~~
                                               hep_job
                                                 y j &&
                                               (0 <
                                                job_cost
                                                 y))
      (job_max_nonpreemptive_segment y - ε))
              rewrite ifT; last by lia.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
NZ: service sched jlp t1 < job_cost jlp
fpt <=
maxn (job_max_nonpreemptive_segment jlp - ε)
  (\max_(y <- rem (T:=Job) jlp
                (arrivals_before arr_seq t1) | ~~
                                               hep_job
                                                 y j &&
                                               (0 <
                                                job_cost
                                                 y))
      (job_max_nonpreemptive_segment y - ε))
              apply leq_trans with (job_max_nonpreemptive_segment jlp - ε);
                first by rewrite leq_add2l in LE.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
NZ: service sched jlp t1 < job_cost jlp
job_max_nonpreemptive_segment jlp - ε <=
maxn (job_max_nonpreemptive_segment jlp - ε)
  (\max_(y <- rem (T:=Job) jlp
                (arrivals_before arr_seq t1) | ~~
                                               hep_job
                                                 y j &&
                                               (0 <
                                                job_cost
                                                 y))
      (job_max_nonpreemptive_segment y - ε))
              by rewrite leq_maxl. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
jlp \in arrivals_before arr_seq t1
            eapply arrived_between_implies_in_arrivals; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
arrived_between jlp 0 t1
            apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
job_arrival jlp < t1
            eapply low_priority_job_arrives_before_busy_interval_prefix with t1; eauto 2.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
progr_t1:= service sched jlp t1: nat
fpt: instant
H_fpt_is_preemptio_point: job_preemptable jlp
  (progr_t1 + fpt)
H_fpt_is_first_preemption_point: forall ρ : nat,
progr_t1 <= ρ <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε) ->
job_preemptable jlp
  ρ ->
service sched jlp t1 +
fpt <= ρ
H_progr_le_max_nonp_segment: progr_t1 <=
progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment
   jlp - ε)
ARRs: arrives_in arr_seq jlp
GE: progr_t1 <= progr_t1 + fpt
LE: progr_t1 + fpt <=
progr_t1 +
(job_max_nonpreemptive_segment jlp - ε)
t1 <= t1 < t2
            by move: (H_busy_interval_prefix) => [NEM [QT1 [NQT HPJ]]]; apply/andP; split.
          Qed.

        End FirstPreemptionPointOfjlp.

        (** Next we combine the facts above to conclude the lemma. *)
        Lemma preemption_time_exists_case3: 
          exists pr_t,
            preemption_time sched pr_t /\
            t1 <= pr_t <= t1 + max_length_of_priority_inversion j t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
        Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          set (service := service sched).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          have EX: exists pt,
              ((service jlp t1) <= pt <= (service jlp t1) + (job_max_nonpreemptive_segment jlp - 1)) && job_preemptable jlp pt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
EX: exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt move: (H_jlp_is_scheduled) => ARRs; apply H_jobs_come_from_arrival_sequence in ARRs.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            move: (proj2 (H_valid_model_with_bounded_nonpreemptive_segments) jlp ARRs) =>[_ EXPP].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: nonpreemptive_regions_have_bounded_length jlp
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            destruct H_sched_valid as [A B].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: nonpreemptive_regions_have_bounded_length jlp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            specialize (EXPP (service jlp t1)).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: 0 <= service jlp t1 <= job_cost jlp ->
exists pp : duration,
  service jlp t1 <= pp <=
  service jlp t1 +
  (job_max_nonpreemptive_segment jlp - ε) /\
  job_preemptable jlp pp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            feed EXPP.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: 0 <= service jlp t1 <= job_cost jlp ->
exists pp : duration,
  service jlp t1 <= pp <=
  service jlp t1 +
  (job_max_nonpreemptive_segment jlp - ε) /\
  job_preemptable jlp pp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
0 <= service jlp t1 <= job_cost jlp
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: exists pp : duration,
  service jlp t1 <= pp <=
  service jlp t1 +
  (job_max_nonpreemptive_segment jlp - ε) /\
  job_preemptable jlp pp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: 0 <= service jlp t1 <= job_cost jlp ->
exists pp : duration,
  service jlp t1 <= pp <=
  service jlp t1 +
  (job_max_nonpreemptive_segment jlp - ε) /\
  job_preemptable jlp pp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
0 <= service jlp t1 <= job_cost jlp apply/andP; split; first by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: 0 <= service jlp t1 <= job_cost jlp ->
exists pp : duration,
  service jlp t1 <= pp <=
  service jlp t1 +
  (job_max_nonpreemptive_segment jlp - ε) /\
  job_preemptable jlp pp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
service jlp t1 <= job_cost jlp
              apply service_at_most_cost; rt_eauto.
            }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
EXPP: exists pp : duration,
  service jlp t1 <= pp <=
  service jlp t1 +
  (job_max_nonpreemptive_segment jlp - ε) /\
  job_preemptable jlp pp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            move: EXPP => [pt [NEQ PP]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
ARRs: arrives_in arr_seq jlp
A: jobs_come_from_arrival_sequence sched arr_seq
B: jobs_must_be_ready_to_execute sched
pt: duration
NEQ: service jlp t1 <= pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - ε)
PP: job_preemptable jlp pt
exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
            exists pt; apply/andP; split; by done.
          }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
EX: exists pt : nat,
  (service jlp t1 <= pt <=
   service jlp t1 +
   (job_max_nonpreemptive_segment jlp - 1)) &&
  job_preemptable jlp pt
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move: (ex_minnP EX) => [sm_pt /andP [NEQ PP] MIN]; clear EX.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          have Fact: exists Δ, sm_pt = service jlp t1 + Δ.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
exists Δ : nat, sm_pt = service jlp t1 + Δ
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
Fact: exists Δ : nat, sm_pt = service jlp t1 + Δ
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          {
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
exists Δ : nat, sm_pt = service jlp t1 + Δ exists (sm_pt - service jlp t1).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
sm_pt = service jlp t1 + (sm_pt - service jlp t1)
            apply/eqP; rewrite eq_sym; apply/eqP; rewrite subnKC //.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
service jlp t1 <= sm_pt
            by move: NEQ => /andP [T _]. }
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
NEQ: service jlp t1 <= sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
PP: job_preemptable jlp sm_pt
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n -> 
sm_pt <= n
Fact: exists Δ : nat, sm_pt = service jlp t1 + Δ
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          move: Fact => [Δ EQ]; subst sm_pt; rename Δ into sm_pt.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
          exists (t1 + sm_pt); split.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
preemption_time sched (t1 + sm_pt)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
t1 <= t1 + sm_pt <=
t1 + max_length_of_priority_inversion j t1
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
preemption_time sched (t1 + sm_pt)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
t1 <= t1 + sm_pt <=
t1 + max_length_of_priority_inversion j t1 apply first_preemption_time.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
job_preemptable jlp
  (service.service sched jlp t1 + sm_pt)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
forall ρ : nat,
service.service sched jlp t1 <= ρ <=
service.service sched jlp t1 +
(job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp ρ ->
service.service sched jlp t1 + sm_pt <= ρ
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
service.service sched jlp t1 <=
service.service sched jlp t1 + sm_pt <=
service.service sched jlp t1 +
(job_max_nonpreemptive_segment jlp - ε)
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
t1 <= t1 + sm_pt <=
t1 + max_length_of_priority_inversion j t1
            all: unfold service.service; try done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
forall ρ : nat,
service_during sched jlp 0 t1 <= ρ <=
service_during sched jlp 0 t1 +
(job_max_nonpreemptive_segment jlp - ε) ->
job_preemptable jlp ρ ->
service_during sched jlp 0 t1 + sm_pt <= ρ
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
t1 <= t1 + sm_pt <=
t1 + max_length_of_priority_inversion j t1
            intros; apply MIN; apply/andP; split; by done.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
t1 <= t1 + sm_pt <=
t1 + max_length_of_priority_inversion j t1
          -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
jlp: Job
H_jlp_is_scheduled: scheduled_at sched jlp t1
H_jlp_low_priority: ~~ hep_job jlp j
service:= service.service sched: Job -> instant -> nat
sm_pt: nat
MIN: forall n : nat,
(service jlp t1 <= n <=
 service jlp t1 +
 (job_max_nonpreemptive_segment jlp - 1)) &&
job_preemptable jlp n ->
service jlp t1 + sm_pt <= n
PP: job_preemptable jlp (service jlp t1 + sm_pt)
NEQ: service jlp t1 <= 
service jlp t1 + sm_pt <=
service jlp t1 +
(job_max_nonpreemptive_segment jlp - 1)
t1 <= t1 + sm_pt <=
t1 + max_length_of_priority_inversion j t1 by apply preemption_time_le_max_len_of_priority_inversion.
        Qed.

      End Case3.
      
    End CaseAnalysis.

    (** By doing the case analysis, we show that indeed there is a
        preemption time in time interval [[t1, t1 +
        max_length_of_priority_inversion j t1]]. *)
    Lemma preemption_time_exists: 
      exists pr_t,
        preemption_time sched pr_t /\
        t1 <= pr_t <= t1 + max_length_of_priority_inversion j t1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
    Proof.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
      set (service := service sched).
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
      move: (H_valid_model_with_bounded_nonpreemptive_segments) => CORR.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
      move: (H_busy_interval_prefix) => [NEM [QT1 [NQT HPJ]]].
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
      ideal_proc_model_sched_case_analysis sched t1 s.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
Idle: is_idle sched t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
Idle: is_idle sched t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1 by apply preemption_time_exists_case1.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
      -
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1 destruct (hep_job s j) eqn:PRIO.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = true
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = false
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
        +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = true
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = false
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1 by eapply preemption_time_exists_case2; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = false
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1
        +
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = false
exists pr_t : instant,
  preemption_time sched pr_t /\
  t1 <= pr_t <=
  t1 + max_length_of_priority_inversion j t1 eapply preemption_time_exists_case3 with s; eauto.
Task: TaskType
H: TaskCost Task
Job: JobType
H0: JobTask Job Task
Arrival: JobArrival Job
Cost: JobCost Job
arr_seq: arrival_sequence Job
H_arrival_times_are_consistent: consistent_arrival_times
  arr_seq
sched: schedule (processor_state Job)
JLFP: JLFP_policy Job
H_priority_is_reflexive: reflexive_priorities
H_priority_is_transitive: transitive_priorities
H1: TaskMaxNonpreemptiveSegment Task
H2: JobPreemptable Job
H_valid_model_with_bounded_nonpreemptive_segments: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
H3: JobReady Job (processor_state Job)
H_job_ready: work_bearing_readiness arr_seq sched
H_sched_valid: valid_schedule sched arr_seq
H_jobs_come_from_arrival_sequence: jobs_come_from_arrival_sequence
  sched arr_seq
H_work_conserving: work_conserving arr_seq sched
H_respects_policy: respects_JLFP_policy_at_preemption_point
  arr_seq sched JLFP
job_scheduled_at:= scheduled_at sched: Job -> instant -> bool
job_completed_by:= completed_by sched: Job -> instant -> bool
j: Job
H_j_arrives: arrives_in arr_seq j
H_job_cost_positive: job_cost_positive j
t1, t2: instant
H_busy_interval_prefix: busy_interval_prefix arr_seq
  sched j t1 t2
service:= service.service sched: Job -> instant -> nat
CORR: valid_model_with_bounded_nonpreemptive_segments
  arr_seq sched
NEM: t1 < t2
QT1: quiet_time arr_seq sched j t1
NQT: forall t : nat,
t1 < t < t2 -> ~ quiet_time arr_seq sched j t
HPJ: t1 <= job_arrival j < t2
s: Job
Sched_s: scheduled_at sched s t1
PRIO: hep_job s j = false
~~ hep_job s j
          by rewrite -eqbF_neg; apply /eqP.
    Qed.
    
  End PreemptionTimeExists.

End PriorityInversionIsBounded.