Library prosa.analysis.facts.transform.edf_opt


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

Welcome to Coq 8.11.2 (June 2020)

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

From mathcomp Require Import ssrnat ssrbool fintype.
Require Export prosa.model.schedule.edf.
Require Export prosa.analysis.definitions.schedulability.
Require Export prosa.analysis.transform.edf_trans.
Require Export prosa.analysis.facts.transform.swaps.
Require Export prosa.analysis.facts.readiness.basic.

This file contains the main argument of the EDF optimality proof, starting with an analysis of the individual functions that drive the piece-wise transformation of a given reference schedule in an EDF schedule, and ending with proofs of individual properties of the obtained EDF schedule.
Throughout this file, we assume ideal uniprocessor schedules.
Require Import prosa.model.processor.ideal.
Throughout this file, we assume the basic (i.e., Liu & Layland) readiness model.
Require Import prosa.model.readiness.basic.

We start by analyzing the helper function [find_swap_candidate], which is a problem-specific wrapper around [search_arg].
Section FindSwapCandidateFacts.

For any given type of jobs...
  Context {Job : JobType} `{JobCost Job} `{JobDeadline Job} `{JobArrival Job}.

...consider an ideal uniprocessor schedule...
  Variable sched: schedule (ideal.processor_state Job).

...that is well-behaved (i.e., in which jobs execute only after having arrived and only if they are not yet complete).
  Hypothesis H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute sched.
  Hypothesis H_completed_jobs_dont_execute: completed_jobs_dont_execute sched.

Suppose we are given a job [j1]...
  Variable j1: Job.

...and a point in time [t1]...
  Variable t1: instant.

...at which [j1] is scheduled...
  Hypothesis H_not_idle: scheduled_at sched j1 t1.

...and that is before its deadline.
  Hypothesis H_deadline_not_missed: t1 < job_deadline j1.

First, we observe that under these assumptions the processor state at time [t1] is "relevant" according to the notion of relevance underlying the EDF transformation, namely [relevant_pstate].
  Lemma t1_relevant: relevant_pstate t1 (sched t1).

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

1 subgoal (ID 2025)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  relevant_pstate t1 (sched t1)

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

  Proof.
    move: H_not_idle.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2026)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  scheduled_at sched j1 t1 -> relevant_pstate t1 (sched t1)

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

rewrite scheduled_at_def ⇒ /eqP →.

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

1 subgoal (ID 2098)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  relevant_pstate t1 (Some j1)

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

    rewrite /relevant_pstate -/(has_arrived j1 t1).

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

1 subgoal (ID 2108)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  has_arrived j1 t1

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

    move: (H_jobs_must_arrive_to_execute j1 t1) ⇒ SCHED_ARR.

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

1 subgoal (ID 2110)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  SCHED_ARR : scheduled_at sched j1 t1 -> has_arrived j1 t1
  ============================
  has_arrived j1 t1

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

    now apply SCHED_ARR.

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

No more subgoals.

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

  Qed.

Since [t1] is relevant, we conclude that a search for a relevant state succeeds (if nothing else, it finds [t1]).
  Lemma fsc_search_successful:
    ∃ t, search_arg sched (relevant_pstate t1) earlier_deadline t1 (job_deadline j1) = Some t.

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

1 subgoal (ID 2039)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  exists t : nat,
    search_arg sched (relevant_pstate t1) earlier_deadline t1
      (job_deadline j1) = Some t

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

  Proof.
    apply search_arg_not_none.

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

1 subgoal (ID 2041)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  exists x : nat, t1 <= x < job_deadline j1 /\ relevant_pstate t1 (sched x)

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

    ∃ t1.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2043)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  t1 <= t1 < job_deadline j1 /\ relevant_pstate t1 (sched t1)

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

split.

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

2 subgoals (ID 2045)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  t1 <= t1 < job_deadline j1

subgoal 2 (ID 2046) is:
 relevant_pstate t1 (sched t1)

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

    - by apply /andP; split.

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

1 subgoal (ID 2046)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  relevant_pstate t1 (sched t1)

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

    - by apply t1_relevant.

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

No more subgoals.

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

  Qed.

For rewriting purposes, we observe that the [search_arg] operation within [find_swap_candidate] yields the final result of [find_swap_candidate].
  Corollary fsc_search_result:
    search_arg sched (relevant_pstate t1) earlier_deadline t1 (job_deadline j1) = Some (find_swap_candidate sched t1 j1).

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

1 subgoal (ID 2053)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  search_arg sched (relevant_pstate t1) earlier_deadline t1 (job_deadline j1) =
  Some (find_swap_candidate sched t1 j1)

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

  Proof.
    move: fsc_search_successful ⇒ [t FOUND].

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

1 subgoal (ID 2065)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  ============================
  search_arg sched (relevant_pstate t1) earlier_deadline t1 (job_deadline j1) =
  Some (find_swap_candidate sched t1 j1)

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

    now rewrite /find_swap_candidate FOUND.

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

No more subgoals.

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

  Qed.

There is a job that is scheduled at the time that [find_swap_candidate] returns, and that job arrives no later than at time [t1].
  Lemma fsc_not_idle:
    ∃ j', (scheduled_at sched j' (find_swap_candidate sched t1 j1))
               ∧ job_arrival j' ≤ t1.

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

1 subgoal (ID 2066)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  exists j' : Job,
    scheduled_at sched j' (find_swap_candidate sched t1 j1) /\
    job_arrival j' <= t1

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

  Proof.
    move: fsc_search_successful ⇒ [t FOUND].

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

1 subgoal (ID 2078)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  ============================
  exists j' : Job,
    scheduled_at sched j' (find_swap_candidate sched t1 j1) /\
    job_arrival j' <= t1

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

    move: (search_arg_pred _ _ _ _ _ _ FOUND).

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

1 subgoal (ID 2092)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  ============================
  relevant_pstate t1 (sched t) ->
  exists j' : Job,
    scheduled_at sched j' (find_swap_candidate sched t1 j1) /\
    job_arrival j' <= t1

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

    rewrite /relevant_pstate.

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

1 subgoal (ID 2097)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  ============================
  match sched t with
  | Some j' => job_arrival j' <= t1
  | None => false
  end ->
  exists j' : Job,
    scheduled_at sched j' (find_swap_candidate sched t1 j1) /\
    job_arrival j' <= t1

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

    destruct (sched t) as [j'|] eqn:SCHED_t ⇒ // ARR_j'.

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

1 subgoal (ID 2170)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  j' : Job
  SCHED_t : sched t = Some j'
  ARR_j' : job_arrival j' <= t1
  ============================
  exists j'0 : Job,
    scheduled_at sched j'0 (find_swap_candidate sched t1 j1) /\
    job_arrival j'0 <= t1

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

    ∃ j'.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2172)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  j' : Job
  SCHED_t : sched t = Some j'
  ARR_j' : job_arrival j' <= t1
  ============================
  scheduled_at sched j' (find_swap_candidate sched t1 j1) /\
  job_arrival j' <= t1

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

split ⇒ //.

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

1 subgoal (ID 2174)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  j' : Job
  SCHED_t : sched t = Some j'
  ARR_j' : job_arrival j' <= t1
  ============================
  scheduled_at sched j' (find_swap_candidate sched t1 j1)

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

    rewrite /find_swap_candidate FOUND.

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

1 subgoal (ID 2206)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  j' : Job
  SCHED_t : sched t = Some j'
  ARR_j' : job_arrival j' <= t1
  ============================
  scheduled_at sched j' t

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

    rewrite scheduled_at_def //.

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

1 subgoal (ID 2213)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  t : nat
  FOUND : search_arg sched (relevant_pstate t1) earlier_deadline t1
            (job_deadline j1) = Some t
  j' : Job
  SCHED_t : sched t = Some j'
  ARR_j' : job_arrival j' <= t1
  ============================
  sched t == Some j'

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

    now apply /eqP.

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

No more subgoals.

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

  Qed.

Since we are considering a uniprocessor model, only one job is scheduled at a time. Hence once we know that a job is scheduled at the time that [find_swap_candidate] returns, we can conclude that it arrives not later than at time t1.
  Corollary fsc_found_job_arrival:
    ∀ j2,
      scheduled_at sched j2 (find_swap_candidate sched t1 j1) →
      job_arrival j2 ≤ t1.

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

1 subgoal (ID 2078)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  forall j2 : Job,
  scheduled_at sched j2 (find_swap_candidate sched t1 j1) ->
  job_arrival j2 <= t1

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

  Proof.
    move⇒ j2 SCHED_j2.

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

1 subgoal (ID 2080)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  ============================
  job_arrival j2 <= t1

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

    move: fsc_not_idle ⇒ [j' [SCHED_j' ARR]].

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

1 subgoal (ID 2102)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  j' : Job
  SCHED_j' : scheduled_at sched j' (find_swap_candidate sched t1 j1)
  ARR : job_arrival j' <= t1
  ============================
  job_arrival j2 <= t1

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

    now rewrite -(ideal_proc_model_is_a_uniprocessor_model _ _ _ _ SCHED_j' SCHED_j2).

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

No more subgoals.

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

  Qed.

We observe that [find_swap_candidate] returns a value within a known finite interval.
  Lemma fsc_range:
    t1 ≤ find_swap_candidate sched t1 j1 < job_deadline j1.

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

1 subgoal (ID 2087)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  t1 <= find_swap_candidate sched t1 j1 < job_deadline j1

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

  Proof. move: fsc_search_result.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2088)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  search_arg sched (relevant_pstate t1) earlier_deadline t1 (job_deadline j1) =
  Some (find_swap_candidate sched t1 j1) ->
  t1 <= find_swap_candidate sched t1 j1 < job_deadline j1

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

by apply search_arg_in_range.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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

Qed.

For convenience, since we often only require the lower bound on the interval, we re-state it as a corollary.
  Corollary fsc_range1:
    t1 ≤ find_swap_candidate sched t1 j1.

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

1 subgoal (ID 2091)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  t1 <= find_swap_candidate sched t1 j1

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

  Proof. by move: fsc_range ⇒ /andP [LE _].
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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

Qed.

The following lemma is a key step of the overall proof: the job scheduled at the time found by [find_swap_candidate] has the property that it has a deadline that is no later than that of any other job in the window given by time [t1] and the deadline of the job scheduled at time [t1].
  Lemma fsc_found_job_deadline:
    ∀ j2,
      scheduled_at sched j2 (find_swap_candidate sched t1 j1) →
      ∀ j t,
        t1 ≤ t < job_deadline j1 →
        scheduled_at sched j t →
        job_arrival j ≤ t1 →
        job_deadline j2 ≤ job_deadline j.

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

1 subgoal (ID 2117)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  forall j2 : Job,
  scheduled_at sched j2 (find_swap_candidate sched t1 j1) ->
  forall (j : Job) (t : nat),
  t1 <= t < job_deadline j1 ->
  scheduled_at sched j t ->
  job_arrival j <= t1 -> job_deadline j2 <= job_deadline j

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

  Proof.
    move⇒ j2 SCHED_j2 j t /andP [t1_le_t t_lt_dl1] SCHED_j ARR_j.

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

1 subgoal (ID 2187)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  SCHED_j : scheduled_at sched j t
  ARR_j : job_arrival j <= t1
  ============================
  job_deadline j2 <= job_deadline j

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

    have TOTAL: total earlier_deadline
      by rewrite /earlier_deadline ⇒ s1 s2; apply leq_total.

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

1 subgoal (ID 2201)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  SCHED_j : scheduled_at sched j t
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  ============================
  job_deadline j2 <= job_deadline j

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

    have TRANS: transitive earlier_deadline
      by rewrite /earlier_deadline ⇒ s1 s2 s3; apply leq_trans.

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

1 subgoal (ID 2216)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  SCHED_j : scheduled_at sched j t
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  ============================
  job_deadline j2 <= job_deadline j

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

    have REFL: reflexive earlier_deadline
      by rewrite /earlier_deadline ⇒ s; apply leqnn.

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

1 subgoal (ID 2229)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  SCHED_j : scheduled_at sched j t
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  ============================
  job_deadline j2 <= job_deadline j

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

    move: SCHED_j SCHED_j2.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2233)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  ============================
  scheduled_at sched j t ->
  scheduled_at sched j2 (find_swap_candidate sched t1 j1) ->
  job_deadline j2 <= job_deadline j

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

rewrite !scheduled_at_def ⇒ /eqP SCHED_j /eqP SCHED_j2.

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

1 subgoal (ID 2373)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  ============================
  job_deadline j2 <= job_deadline j

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

    have ED: earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched t).

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

2 subgoals (ID 2379)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  ============================
  earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched t)

subgoal 2 (ID 2381) is:
 job_deadline j2 <= job_deadline j

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

    {

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

1 subgoal (ID 2379)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  ============================
  earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched t)

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

      move: (search_arg_extremum _ _ _ REFL TRANS TOTAL _ _ _ fsc_search_result) ⇒ MIN.

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

1 subgoal (ID 2396)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  MIN : forall y : nat,
        t1 <= y < job_deadline j1 ->
        relevant_pstate t1 (sched y) ->
        earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched y)
  ============================
  earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched t)

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

      apply (MIN t).

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

2 subgoals (ID 2397)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  MIN : forall y : nat,
        t1 <= y < job_deadline j1 ->
        relevant_pstate t1 (sched y) ->
        earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched y)
  ============================
  t1 <= t < job_deadline j1

subgoal 2 (ID 2398) is:
 relevant_pstate t1 (sched t)

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

      - by apply /andP; split.

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

1 subgoal (ID 2398)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  MIN : forall y : nat,
        t1 <= y < job_deadline j1 ->
        relevant_pstate t1 (sched y) ->
        earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched y)
  ============================
  relevant_pstate t1 (sched t)

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

      - by rewrite /relevant_pstate SCHED_j.

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

1 subgoal (ID 2381)

subgoal 1 (ID 2381) is:
 job_deadline j2 <= job_deadline j

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

    }

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

1 subgoal (ID 2381)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2, j : Job
  t : nat
  t1_le_t : t1 <= t
  t_lt_dl1 : t < job_deadline j1
  ARR_j : job_arrival j <= t1
  TOTAL : total (T:=processor_state Job) earlier_deadline
  TRANS : transitive (T:=processor_state Job) earlier_deadline
  REFL : reflexive (T:=processor_state Job) earlier_deadline
  SCHED_j : sched t = Some j
  SCHED_j2 : sched (find_swap_candidate sched t1 j1) = Some j2
  ED : earlier_deadline (sched (find_swap_candidate sched t1 j1)) (sched t)
  ============================
  job_deadline j2 <= job_deadline j

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

    now move: ED; rewrite /earlier_deadline /oapp SCHED_j SCHED_j2.

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

No more subgoals.

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

  Qed.

As a special case of the above lemma, we observe that the job scheduled at the time given by [find_swap_candidate] in particular has a deadline no later than the job scheduled at time [t1].
  Corollary fsc_no_later_deadline:
    ∀ j2,
      scheduled_at sched j2 (find_swap_candidate sched t1 j1) →
      job_deadline j2 ≤ job_deadline j1.

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

1 subgoal (ID 2131)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  ============================
  forall j2 : Job,
  scheduled_at sched j2 (find_swap_candidate sched t1 j1) ->
  job_deadline j2 <= job_deadline j1

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

  Proof.
    move⇒ j2 SCHED_j2.

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

1 subgoal (ID 2133)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  ============================
  job_deadline j2 <= job_deadline j1

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

    apply fsc_found_job_deadline with (t := t1) ⇒ //.

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

2 subgoals (ID 2135)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  ============================
  t1 <= t1 < job_deadline j1

subgoal 2 (ID 2137) is:
 job_arrival j1 <= t1

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

    - by apply /andP; split.

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

1 subgoal (ID 2137)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  j1 : Job
  t1 : instant
  H_not_idle : scheduled_at sched j1 t1
  H_deadline_not_missed : t1 < job_deadline j1
  j2 : Job
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t1 j1)
  ============================
  job_arrival j1 <= t1

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

    - by apply H_jobs_must_arrive_to_execute.

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

No more subgoals.

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

  Qed.

End FindSwapCandidateFacts.

In the next section, we analyze properties of [make_edf_at], which we abbreviate as "[mea]" in the following.
Section MakeEDFAtFacts.

For any given type of jobs...
  Context {Job : JobType} `{JobCost Job} `{JobDeadline Job} `{JobArrival Job}.

...consider an ideal uniprocessor schedule...
  Variable sched: schedule (ideal.processor_state Job).

...that is well-behaved...
  Hypothesis H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute sched.
  Hypothesis H_completed_jobs_dont_execute: completed_jobs_dont_execute sched.

...and in which no scheduled job misses a deadline.
  Hypothesis H_no_deadline_misses: all_deadlines_met sched.

Since we will require this fact repeatedly, we briefly observe that, since no scheduled job misses its deadline, if a job is scheduled at some time [t], then its deadline is later than [t].
  Fact scheduled_job_in_sched_has_later_deadline:
    ∀ j t,
      scheduled_at sched j t →
      job_deadline j > t.

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

1 subgoal (ID 2033)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched j t -> t < job_deadline j

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

  Proof.
    move⇒ j t SCHED.

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

1 subgoal (ID 2036)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  j : Job
  t : instant
  SCHED : scheduled_at sched j t
  ============================
  t < job_deadline j

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

    apply (scheduled_at_implies_later_deadline sched) ⇒ //.

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

2 subgoals (ID 2044)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  j : Job
  t : instant
  SCHED : scheduled_at sched j t
  ============================
  ideal_progress_proc_model (option_eqType Job)

subgoal 2 (ID 2045) is:
 job_meets_deadline sched j

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

    - by apply ideal_proc_model_ensures_ideal_progress.

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

1 subgoal (ID 2045)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  j : Job
  t : instant
  SCHED : scheduled_at sched j t
  ============================
  job_meets_deadline sched j

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

    - by apply (H_no_deadline_misses _ t).

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

No more subgoals.

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

  Qed.

We analyze [make_edf_at] applied to an arbitrary point in time, which we denote [t_edf] in the following.
  Variable t_edf: instant.

For brevity, let [sched'] denote the schedule obtained from [make_edf_at] applied to [sched] at time [t_edf].
  Let sched' := make_edf_at sched t_edf.

First, we observe that in [sched'] jobs still don't execute past completion.
  Lemma mea_completed_jobs:
    completed_jobs_dont_execute sched'.

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

1 subgoal (ID 2041)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  completed_jobs_dont_execute sched'

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

  Proof.
    have IDEAL := @ideal_proc_model_ensures_ideal_progress Job.

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

1 subgoal (ID 2046)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  ============================
  completed_jobs_dont_execute sched'

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

    have UNIT := @ideal_proc_model_provides_unit_service Job.

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

1 subgoal (ID 2051)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  UNIT : unit_service_proc_model (processor_state Job)
  ============================
  completed_jobs_dont_execute sched'

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

    rewrite /sched' /make_edf_at.

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

1 subgoal (ID 2059)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  UNIT : unit_service_proc_model (processor_state Job)
  ============================
  completed_jobs_dont_execute
    match sched t_edf with
    | Some j => swapped sched t_edf (find_swap_candidate sched t_edf j)
    | None => sched
    end

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED; last by done.

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

1 subgoal (ID 2072)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  UNIT : unit_service_proc_model (processor_state Job)
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  ============================
  completed_jobs_dont_execute
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))

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

    have SCHED': scheduled_at sched j_orig t_edf
      by rewrite scheduled_at_def; apply /eqP.

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

1 subgoal (ID 2142)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  UNIT : unit_service_proc_model (processor_state Job)
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  ============================
  completed_jobs_dont_execute
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))

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

    apply swapped_completed_jobs_dont_execute ⇒ //.

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

1 subgoal (ID 2147)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  UNIT : unit_service_proc_model (processor_state Job)
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  ============================
  t_edf <= find_swap_candidate sched t_edf j_orig

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

    apply fsc_range1 ⇒ //.

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

1 subgoal (ID 2178)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  IDEAL : ideal_progress_proc_model (processor_state Job)
  UNIT : unit_service_proc_model (processor_state Job)
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  ============================
  t_edf < job_deadline j_orig

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

    now apply scheduled_job_in_sched_has_later_deadline.

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

No more subgoals.

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

  Qed.

Importantly, [make_edf_at] does not introduce any deadline misses, which is a crucial step in the EDF optimality argument.
  Lemma mea_no_deadline_misses:
    all_deadlines_met sched'.

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

1 subgoal (ID 2048)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  all_deadlines_met sched'

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

  Proof.
    move⇒ j t SCHED.

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

1 subgoal (ID 2052)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  job_meets_deadline sched' j

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

    rewrite /sched' /make_edf_at.

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

1 subgoal (ID 2060)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  job_meets_deadline
    match sched t_edf with
    | Some j0 => swapped sched t_edf (find_swap_candidate sched t_edf j0)
    | None => sched
    end j

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED_orig; last first.

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

2 subgoals (ID 2074)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  SCHED_orig : sched t_edf = None
  ============================
  job_meets_deadline sched j

subgoal 2 (ID 2073) is:
 job_meets_deadline
   (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j

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

    {

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

1 subgoal (ID 2074)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  SCHED_orig : sched t_edf = None
  ============================
  job_meets_deadline sched j

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

      apply (H_no_deadline_misses _ t).

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

1 subgoal (ID 2077)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  SCHED_orig : sched t_edf = None
  ============================
  scheduled_at sched j t

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

      move: SCHED.

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

1 subgoal (ID 2079)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_orig : sched t_edf = None
  ============================
  scheduled_at sched' j t -> scheduled_at sched j t

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

      now rewrite /sched' /make_edf_at SCHED_orig.

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

1 subgoal (ID 2073)

subgoal 1 (ID 2073) is:
 job_meets_deadline
   (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j

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

    }

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

1 subgoal (ID 2073)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  ============================
  job_meets_deadline
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j

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

    {

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

1 subgoal (ID 2073)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  ============================
  job_meets_deadline
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j

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

      have SCHED': scheduled_at sched j_orig t_edf
        by rewrite scheduled_at_def; apply /eqP.

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

1 subgoal (ID 2159)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  ============================
  job_meets_deadline
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j

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

      move: (scheduled_job_in_sched_has_later_deadline _ _ SCHED') ⇒ DL_orig.

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

1 subgoal (ID 2165)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  job_meets_deadline
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j

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

      apply edf_swap_no_deadline_misses_introduced ⇒ //.

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

5 subgoals (ID 2172)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  ideal_progress_proc_model (option_eqType Job)

subgoal 2 (ID 2173) is:
 t_edf <= find_swap_candidate sched t_edf j_orig
subgoal 3 (ID 2174) is:
 forall j1 j2 : Job,
 scheduled_at sched j1 t_edf ->
 scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) ->
 job_deadline j2 <= job_deadline j1
subgoal 4 (ID 2175) is:
 forall j1 : Job,
 scheduled_at sched j1 t_edf ->
 exists j2 : Job,
   scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
   find_swap_candidate sched t_edf j_orig < job_deadline j2
subgoal 5 (ID 2176) is:
 job_meets_deadline sched j

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

      - by apply ideal_proc_model_ensures_ideal_progress.

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

4 subgoals (ID 2173)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  t_edf <= find_swap_candidate sched t_edf j_orig

subgoal 2 (ID 2174) is:
 forall j1 j2 : Job,
 scheduled_at sched j1 t_edf ->
 scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) ->
 job_deadline j2 <= job_deadline j1
subgoal 3 (ID 2175) is:
 forall j1 : Job,
 scheduled_at sched j1 t_edf ->
 exists j2 : Job,
   scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
   find_swap_candidate sched t_edf j_orig < job_deadline j2
subgoal 4 (ID 2176) is:
 job_meets_deadline sched j

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

      - by apply fsc_range1 ⇒ //.

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

3 subgoals (ID 2174)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  forall j1 j2 : Job,
  scheduled_at sched j1 t_edf ->
  scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) ->
  job_deadline j2 <= job_deadline j1

subgoal 2 (ID 2175) is:
 forall j1 : Job,
 scheduled_at sched j1 t_edf ->
 exists j2 : Job,
   scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
   find_swap_candidate sched t_edf j_orig < job_deadline j2
subgoal 3 (ID 2176) is:
 job_meets_deadline sched j

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

      - move⇒ j1 j2 SCHED_j1 SCHED_j2.

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

3 subgoals (ID 2317)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1, j2 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig)
  ============================
  job_deadline j2 <= job_deadline j1

subgoal 2 (ID 2175) is:
 forall j1 : Job,
 scheduled_at sched j1 t_edf ->
 exists j2 : Job,
   scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
   find_swap_candidate sched t_edf j_orig < job_deadline j2
subgoal 3 (ID 2176) is:
 job_meets_deadline sched j

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

        apply: (fsc_found_job_deadline sched _ j_orig t_edf _ _ _ _ _ t_edf) ⇒ //.

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

4 focused subgoals
(shelved: 2) (ID 2403)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1, j2 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig)
  ============================
  t_edf <= t_edf < job_deadline j_orig

subgoal 2 (ID 2405) is:
 job_arrival j1 <= t_edf
subgoal 3 (ID 2175) is:
 forall j1 : Job,
 scheduled_at sched j1 t_edf ->
 exists j2 : Job,
   scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
   find_swap_candidate sched t_edf j_orig < job_deadline j2
subgoal 4 (ID 2176) is:
 job_meets_deadline sched j

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

        + by apply /andP; split.

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

3 focused subgoals
(shelved: 1) (ID 2405)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1, j2 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  SCHED_j2 : scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig)
  ============================
  job_arrival j1 <= t_edf

subgoal 2 (ID 2175) is:
 forall j1 : Job,
 scheduled_at sched j1 t_edf ->
 exists j2 : Job,
   scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
   find_swap_candidate sched t_edf j_orig < job_deadline j2
subgoal 3 (ID 2176) is:
 job_meets_deadline sched j

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

        + by apply H_jobs_must_arrive_to_execute.

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

2 subgoals (ID 2175)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  forall j1 : Job,
  scheduled_at sched j1 t_edf ->
  exists j2 : Job,
    scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
    find_swap_candidate sched t_edf j_orig < job_deadline j2

subgoal 2 (ID 2176) is:
 job_meets_deadline sched j

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

      - move⇒ j1 SCHED_j1.

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

2 subgoals (ID 2503)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  ============================
  exists j2 : Job,
    scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
    find_swap_candidate sched t_edf j_orig < job_deadline j2

subgoal 2 (ID 2176) is:
 job_meets_deadline sched j

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

        move: (fsc_not_idle sched H_jobs_must_arrive_to_execute j_orig t_edf SCHED' DL_orig) ⇒ [j' [SCHED_j' ARR_j']].

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

2 subgoals (ID 2528)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  j' : Job
  SCHED_j' : scheduled_at sched j' (find_swap_candidate sched t_edf j_orig)
  ARR_j' : job_arrival j' <= t_edf
  ============================
  exists j2 : Job,
    scheduled_at sched j2 (find_swap_candidate sched t_edf j_orig) /\
    find_swap_candidate sched t_edf j_orig < job_deadline j2

subgoal 2 (ID 2176) is:
 job_meets_deadline sched j

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

        ∃ j'.
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2530)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  j' : Job
  SCHED_j' : scheduled_at sched j' (find_swap_candidate sched t_edf j_orig)
  ARR_j' : job_arrival j' <= t_edf
  ============================
  scheduled_at sched j' (find_swap_candidate sched t_edf j_orig) /\
  find_swap_candidate sched t_edf j_orig < job_deadline j'

subgoal 2 (ID 2176) is:
 job_meets_deadline sched j

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

split ⇒ //.

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

2 subgoals (ID 2533)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  j1 : Job
  SCHED_j1 : scheduled_at sched j1 t_edf
  j' : Job
  SCHED_j' : scheduled_at sched j' (find_swap_candidate sched t_edf j_orig)
  ARR_j' : job_arrival j' <= t_edf
  ============================
  find_swap_candidate sched t_edf j_orig < job_deadline j'

subgoal 2 (ID 2176) is:
 job_meets_deadline sched j

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

        now apply scheduled_job_in_sched_has_later_deadline.

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

1 subgoal (ID 2176)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  job_meets_deadline sched j

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

      - have EX: (∃ t', scheduled_at sched j t').

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

2 subgoals (ID 2562)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  exists t' : instant, scheduled_at sched j t'

subgoal 2 (ID 2564) is:
 job_meets_deadline sched j

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

        {

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

1 subgoal (ID 2562)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  exists t' : instant, scheduled_at sched j t'

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

          apply swap_job_scheduled with (t1 := t_edf) (t2 := find_swap_candidate sched t_edf j_orig) (t0 := t).

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

1 subgoal (ID 2571)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j t

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

          now move: SCHED; rewrite /sched' /make_edf_at SCHED_orig.

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

1 subgoal (ID 2564)

subgoal 1 (ID 2564) is:
 job_meets_deadline sched j

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

        }

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

1 subgoal (ID 2564)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  EX : exists t' : instant, scheduled_at sched j t'
  ============================
  job_meets_deadline sched j

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

        move: EX ⇒ [t' SCHED_t'].

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

1 subgoal (ID 2597)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  t' : instant
  SCHED_t' : scheduled_at sched j t'
  ============================
  job_meets_deadline sched j

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

        now apply H_no_deadline_misses with (t := t').

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

No more subgoals.

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

    }

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

No more subgoals.

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

  Qed.

As a result, we may conclude that any job scheduled at a time t has a deadline later than t.
  Corollary mea_scheduled_job_has_later_deadline:
    ∀ j t,
      scheduled_at sched' j t →
      job_deadline j > t.

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

1 subgoal (ID 2058)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched' j t -> t < job_deadline j

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

  Proof.
    move⇒ j t SCHED.

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

1 subgoal (ID 2061)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  t < job_deadline j

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

    apply (scheduled_at_implies_later_deadline sched') ⇒ //.

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

3 subgoals (ID 2068)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  completed_jobs_dont_execute sched'

subgoal 2 (ID 2069) is:
 ideal_progress_proc_model (option_eqType Job)
subgoal 3 (ID 2070) is:
 job_meets_deadline sched' j

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

    - by apply mea_completed_jobs.

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

2 subgoals (ID 2069)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  ideal_progress_proc_model (option_eqType Job)

subgoal 2 (ID 2070) is:
 job_meets_deadline sched' j

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

    - by apply ideal_proc_model_ensures_ideal_progress.

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

1 subgoal (ID 2070)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  job_meets_deadline sched' j

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

    - by apply mea_no_deadline_misses with (t := t).

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

No more subgoals.

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

  Qed.

Next comes a big step in the optimality proof: we observe that [make_edf_at] indeed ensures that [EDF_at] holds at time [t_edf] in [sched']. As this is a larger argument, we proceed by case analysis and first establish a couple of helper lemmas in the following section.
  Section GuaranteeCaseAnalysis.

Let [j_orig] denote the job scheduled in [sched] at time [t_edf], let [j_edf] denote the job scheduled in [sched'] at time [t_edf], and let [j'] denote any job scheduled in [sched'] at some time [t'] after [t_edf]...
    Variable j_orig j_edf j': Job.

    Variable t': instant.
    Hypothesis H_t_edf_le_t' : t_edf ≤ t'.

    Hypothesis H_sched_orig: scheduled_at sched j_orig t_edf.
    Hypothesis H_sched_edf: scheduled_at sched' j_edf t_edf.
    Hypothesis H_sched': scheduled_at sched' j' t'.

... and that arrives before time [t_edf].
    Hypothesis H_arrival_j' : job_arrival j' ≤ t_edf.

We begin by observing three simple facts that will be used repeatedly in the case analysis.
First, the deadline of [j_orig] is later than [t_edf].
    Fact mea_guarantee_dl_orig: t_edf < job_deadline j_orig.

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

1 subgoal (ID 2072)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  t_edf < job_deadline j_orig

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

    Proof. by apply (scheduled_job_in_sched_has_later_deadline j_orig t_edf H_sched_orig).
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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

Qed.

Second, by the definition of [sched'], [j_edf] is scheduled in [sched] at the time returned by [find_swap_candidate].
    Fact mea_guarantee_fsc_is_j_edf: sched (find_swap_candidate sched t_edf j_orig) = Some j_edf.

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

1 subgoal (ID 2079)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

    Proof.
      move: (H_sched_orig).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2080)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  scheduled_at sched j_orig t_edf ->
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

rewrite scheduled_at_def ⇒ /eqP SCHED.

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

1 subgoal (ID 2149)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  ============================
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

      move: (H_sched_edf).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2150)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  ============================
  scheduled_at sched' j_edf t_edf ->
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

rewrite /sched' /make_edf_at /swapped /replace_at {1}SCHED //=.

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

1 subgoal (ID 2167)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  ============================
  scheduled_at
    (fun t : instant =>
     if find_swap_candidate sched t_edf j_orig == t
     then sched t_edf
     else
      if t_edf == t
      then sched (find_swap_candidate sched t_edf j_orig)
      else sched t) j_edf t_edf ->
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

      rewrite scheduled_at_def.

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

1 subgoal (ID 2198)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  ============================
  (if find_swap_candidate sched t_edf j_orig == t_edf
   then sched t_edf
   else
    if t_edf == t_edf
    then sched (find_swap_candidate sched t_edf j_orig)
    else sched t_edf) == Some j_edf ->
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

      destruct (find_swap_candidate sched t_edf j_orig == t_edf) eqn:FSC.

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

2 subgoals (ID 2214)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  FSC : (find_swap_candidate sched t_edf j_orig == t_edf) = true
  ============================
  sched t_edf == Some j_edf ->
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

subgoal 2 (ID 2215) is:
 (if t_edf == t_edf
  then sched (find_swap_candidate sched t_edf j_orig)
  else sched t_edf) == Some j_edf ->
 sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

      - by move: FSC ⇒ /eqP → /eqP.

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

1 subgoal (ID 2215)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  FSC : (find_swap_candidate sched t_edf j_orig == t_edf) = false
  ============================
  (if t_edf == t_edf
   then sched (find_swap_candidate sched t_edf j_orig)
   else sched t_edf) == Some j_edf ->
  sched (find_swap_candidate sched t_edf j_orig) = Some j_edf

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

      - by rewrite ifT // ⇒ /eqP.

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

No more subgoals.

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

    Qed.

Third, the deadline of [j_edf] is no later than the deadline of [j_orig].
    Fact mea_guarantee_deadlines: job_deadline j_edf ≤ job_deadline j_orig.

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

1 subgoal (ID 2084)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  job_deadline j_edf <= job_deadline j_orig

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

    Proof.
      apply: (fsc_no_later_deadline sched _ _ t_edf) ⇒ //.

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

2 focused subgoals
(shelved: 2) (ID 2145)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  t_edf < job_deadline j_orig

subgoal 2 (ID 2146) is:
 scheduled_at sched j_edf (find_swap_candidate sched t_edf j_orig)

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

      - by exact mea_guarantee_dl_orig.

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

1 focused subgoal
(shelved: 1) (ID 2146)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  scheduled_at sched j_edf (find_swap_candidate sched t_edf j_orig)

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

      - by rewrite scheduled_at_def mea_guarantee_fsc_is_j_edf //=.

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

No more subgoals.

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

    Qed.

With the setup in place, we are now ready to begin the case analysis.
First, we consider the simpler case where [t'] is no earlier than the deadline of [j_orig]. This case is simpler because [t'] being no earlier than [j_orig]'s deadline implies that [j'] has deadline no earlier than [j_orig] (since no scheduled job in [sched] misses a deadline), which in turn has a deadline no earlier than [j_edf].
    Lemma mea_guarantee_case_t'_past_deadline:
      job_deadline j_orig ≤ t' →
      job_deadline j_edf ≤ job_deadline j'.

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

1 subgoal (ID 2091)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  job_deadline j_orig <= t' -> job_deadline j_edf <= job_deadline j'

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

    Proof.
      move: (mea_scheduled_job_has_later_deadline j' t' H_sched') ⇒ DL_j' BOUND_t'.

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

1 subgoal (ID 2094)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  DL_j' : t' < job_deadline j'
  BOUND_t' : job_deadline j_orig <= t'
  ============================
  job_deadline j_edf <= job_deadline j'

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

      apply leq_trans with (n := job_deadline j_orig) ⇒ // ;
        first by exact mea_guarantee_deadlines.

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

1 subgoal (ID 2098)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  DL_j' : t' < job_deadline j'
  BOUND_t' : job_deadline j_orig <= t'
  ============================
  job_deadline j_orig <= job_deadline j'

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

      apply leq_trans with (n := t') ⇒ //.

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

1 subgoal (ID 2144)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  DL_j' : t' < job_deadline j'
  BOUND_t' : job_deadline j_orig <= t'
  ============================
  t' <= job_deadline j'

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

      now apply ltnW.

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

No more subgoals.

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

    Qed.

Next, we consider the more difficult case, where [t'] is before the deadline of [j_orig].
    Lemma mea_guarantee_case_t'_before_deadline:
      t' < job_deadline j_orig →
      job_deadline j_edf ≤ job_deadline j'.

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

1 subgoal (ID 2098)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  t' < job_deadline j_orig -> job_deadline j_edf <= job_deadline j'

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

    Proof.
      move: (H_sched_orig).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2099)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  scheduled_at sched j_orig t_edf ->
  t' < job_deadline j_orig -> job_deadline j_edf <= job_deadline j'

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

rewrite scheduled_at_def ⇒ /eqP SCHED BOUND_t'.

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

1 subgoal (ID 2169)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  ============================
  job_deadline j_edf <= job_deadline j'

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

      move: (mea_guarantee_fsc_is_j_edf) ⇒ FSC.

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

1 subgoal (ID 2171)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  ============================
  job_deadline j_edf <= job_deadline j'

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

      have EX: (∃ x, scheduled_at sched j' x ∧ t_edf ≤ x < job_deadline j_orig).

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

2 subgoals (ID 2179)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

subgoal 2 (ID 2181) is:
 job_deadline j_edf <= job_deadline j'

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

      {

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

1 subgoal (ID 2179)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

        case: (boolP(t_edf == t')) ⇒ [/eqP EQ| /eqP NEQ].

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

2 subgoals (ID 2324)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  EQ : t_edf = t'
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

subgoal 2 (ID 2325) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

        - ∃ (find_swap_candidate sched t_edf j_orig).

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

2 subgoals (ID 2330)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  EQ : t_edf = t'
  ============================
  scheduled_at sched j' (find_swap_candidate sched t_edf j_orig) /\
  t_edf <= find_swap_candidate sched t_edf j_orig < job_deadline j_orig

subgoal 2 (ID 2325) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

          split; last by apply fsc_range ⇒ //; exact mea_guarantee_dl_orig.

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

2 subgoals (ID 2332)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  EQ : t_edf = t'
  ============================
  scheduled_at sched j' (find_swap_candidate sched t_edf j_orig)

subgoal 2 (ID 2325) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

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

2 subgoals (ID 2381)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t' : instant
  j_orig : Job
  SCHED : sched t' = Some j_orig
  j' : Job
  H_arrival_j' : job_arrival j' <= t'
  sched' := make_edf_at sched t' : schedule (processor_state Job)
  H_sched' : scheduled_at sched' j' t'
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t'
  H_sched_orig : scheduled_at sched j_orig t'
  H_t_edf_le_t' : t' <= t'
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t' j_orig) = Some j_edf
  ============================
  scheduled_at sched j' (find_swap_candidate sched t' j_orig)

subgoal 2 (ID 2325) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

rewrite -(ideal_proc_model_is_a_uniprocessor_model _ _ _ _ H_sched_edf H_sched').

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

2 subgoals (ID 2401)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t' : instant
  j_orig : Job
  SCHED : sched t' = Some j_orig
  j' : Job
  H_arrival_j' : job_arrival j' <= t'
  sched' := make_edf_at sched t' : schedule (processor_state Job)
  H_sched' : scheduled_at sched' j' t'
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t'
  H_sched_orig : scheduled_at sched j_orig t'
  H_t_edf_le_t' : t' <= t'
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t' j_orig) = Some j_edf
  ============================
  scheduled_at sched j_edf (find_swap_candidate sched t' j_orig)

subgoal 2 (ID 2325) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

          now rewrite scheduled_at_def FSC //=.

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

1 subgoal (ID 2325)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

        - case: (boolP(find_swap_candidate sched t_edf j_orig == t')) ⇒ [/eqP EQ' | /eqP NEQ'].

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

2 subgoals (ID 2571)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  EQ' : find_swap_candidate sched t_edf j_orig = t'
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

subgoal 2 (ID 2572) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

          + ∃ t_edf.

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

2 subgoals (ID 2574)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  EQ' : find_swap_candidate sched t_edf j_orig = t'
  ============================
  scheduled_at sched j' t_edf /\ t_edf <= t_edf < job_deadline j_orig

subgoal 2 (ID 2572) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

            split; last by apply /andP; split ⇒ //; exact mea_guarantee_dl_orig.

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

2 subgoals (ID 2576)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  EQ' : find_swap_candidate sched t_edf j_orig = t'
  ============================
  scheduled_at sched j' t_edf

subgoal 2 (ID 2572) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

            rewrite -(swap_job_scheduled_t2 _ _ (find_swap_candidate sched t_edf j_orig) _).

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

2 subgoals (ID 2677)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  EQ' : find_swap_candidate sched t_edf j_orig = t'
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' (find_swap_candidate sched t_edf j_orig)

subgoal 2 (ID 2572) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

            move: H_sched'.
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2678)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  EQ' : find_swap_candidate sched t_edf j_orig = t'
  ============================
  scheduled_at sched' j' t' ->
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' (find_swap_candidate sched t_edf j_orig)

subgoal 2 (ID 2572) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

rewrite /sched' /make_edf_at SCHED.

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

2 subgoals (ID 2688)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  EQ' : find_swap_candidate sched t_edf j_orig = t'
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' t' ->
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' (find_swap_candidate sched t_edf j_orig)

subgoal 2 (ID 2572) is:
 exists x : instant,
   scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

            now rewrite EQ'.

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

1 subgoal (ID 2572)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf <> t'
  NEQ' : find_swap_candidate sched t_edf j_orig <> t'
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

          + move: NEQ NEQ' ⇒ /eqP NEQ /eqP NEQ'.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2896)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf != t'
  NEQ' : find_swap_candidate sched t_edf j_orig != t'
  ============================
  exists x : instant,
    scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig

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

∃ t'.

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

1 subgoal (ID 2898)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf != t'
  NEQ' : find_swap_candidate sched t_edf j_orig != t'
  ============================
  scheduled_at sched j' t' /\ t_edf <= t' < job_deadline j_orig

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

            split; last by apply /andP; split.

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

1 subgoal (ID 2900)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf != t'
  NEQ' : find_swap_candidate sched t_edf j_orig != t'
  ============================
  scheduled_at sched j' t'

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

            rewrite -(swap_job_scheduled_other_times _ t_edf (find_swap_candidate sched t_edf j_orig)) //.

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

1 subgoal (ID 2974)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf != t'
  NEQ' : find_swap_candidate sched t_edf j_orig != t'
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' t'

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

            move: H_sched'.

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

1 subgoal (ID 2999)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  NEQ : t_edf != t'
  NEQ' : find_swap_candidate sched t_edf j_orig != t'
  ============================
  scheduled_at sched' j' t' ->
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' t'

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

            now rewrite /sched' /make_edf_at SCHED.

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

1 subgoal (ID 2181)

subgoal 1 (ID 2181) is:
 job_deadline j_edf <= job_deadline j'

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

      }

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

1 subgoal (ID 2181)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  EX : exists x : instant,
         scheduled_at sched j' x /\ t_edf <= x < job_deadline j_orig
  ============================
  job_deadline j_edf <= job_deadline j'

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

      move: EX ⇒ [t'' [SCHED'' RANGE]].

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

1 subgoal (ID 3033)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  t'' : instant
  SCHED'' : scheduled_at sched j' t''
  RANGE : t_edf <= t'' < job_deadline j_orig
  ============================
  job_deadline j_edf <= job_deadline j'

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

      apply: (fsc_found_job_deadline sched _ j_orig t_edf _ _ _ _ _ t'') ⇒ // ;
        first by exact mea_guarantee_dl_orig.

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

1 focused subgoal
(shelved: 1) (ID 3118)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_orig, j_edf, j' : Job
  t' : instant
  H_t_edf_le_t' : t_edf <= t'
  H_sched_orig : scheduled_at sched j_orig t_edf
  H_sched_edf : scheduled_at sched' j_edf t_edf
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  SCHED : sched t_edf = Some j_orig
  BOUND_t' : t' < job_deadline j_orig
  FSC : sched (find_swap_candidate sched t_edf j_orig) = Some j_edf
  t'' : instant
  SCHED'' : scheduled_at sched j' t''
  RANGE : t_edf <= t'' < job_deadline j_orig
  ============================
  scheduled_at sched j_edf (find_swap_candidate sched t_edf j_orig)

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

      now rewrite scheduled_at_def FSC //=.

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

No more subgoals.

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

    Qed.

  End GuaranteeCaseAnalysis.

Finally, putting the preceding cases together, we obtain the result that [make_edf_at] establishes [EDF_at] at time [t_edf].
  Lemma make_edf_at_guarantee:
    EDF_at sched' t_edf.

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

1 subgoal (ID 2065)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  EDF_at sched' t_edf

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

  Proof.
    move⇒ j_edf H_sched_edf t' j' t_edf_le_t' H_sched' H_arrival_j'.

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

1 subgoal (ID 2073)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t_edf
  t' : instant
  j' : Job
  t_edf_le_t' : t_edf <= t'
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  ============================
  job_deadline j_edf <= job_deadline j'

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED;
      last by move: (H_sched_edf); rewrite /sched' /make_edf_at scheduled_at_def ⇒ /eqP; rewrite !SCHED.

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

1 subgoal (ID 2084)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t_edf
  t' : instant
  j' : Job
  t_edf_le_t' : t_edf <= t'
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  ============================
  job_deadline j_edf <= job_deadline j'

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

    have H_sched: scheduled_at sched j_orig t_edf
      by rewrite scheduled_at_def; apply /eqP.

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

1 subgoal (ID 2259)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t_edf
  t' : instant
  j' : Job
  t_edf_le_t' : t_edf <= t'
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  H_sched : scheduled_at sched j_orig t_edf
  ============================
  job_deadline j_edf <= job_deadline j'

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

    case: (boolP (t' < job_deadline j_orig)).

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

2 subgoals (ID 2277)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t_edf
  t' : instant
  j' : Job
  t_edf_le_t' : t_edf <= t'
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  H_sched : scheduled_at sched j_orig t_edf
  ============================
  t' < job_deadline j_orig -> job_deadline j_edf <= job_deadline j'

subgoal 2 (ID 2278) is:
 ~~ (t' < job_deadline j_orig) -> job_deadline j_edf <= job_deadline j'

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

    - by apply mea_guarantee_case_t'_before_deadline.

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

1 subgoal (ID 2278)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t_edf
  t' : instant
  j' : Job
  t_edf_le_t' : t_edf <= t'
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  H_sched : scheduled_at sched j_orig t_edf
  ============================
  ~~ (t' < job_deadline j_orig) -> job_deadline j_edf <= job_deadline j'

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

    - rewrite -leqNgt ⇒ BOUND_t'.

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

1 subgoal (ID 2288)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j_edf : Job
  H_sched_edf : scheduled_at sched' j_edf t_edf
  t' : instant
  j' : Job
  t_edf_le_t' : t_edf <= t'
  H_sched' : scheduled_at sched' j' t'
  H_arrival_j' : job_arrival j' <= t_edf
  j_orig : Job
  SCHED : sched t_edf = Some j_orig
  H_sched : scheduled_at sched j_orig t_edf
  BOUND_t' : job_deadline j_orig <= t'
  ============================
  job_deadline j_edf <= job_deadline j'

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

      now apply: (mea_guarantee_case_t'_past_deadline j_orig j_edf j' t').

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

No more subgoals.

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

  Qed.

We observe that [make_edf_at] maintains the property that jobs must arrive to execute.
  Lemma mea_jobs_must_arrive:
    jobs_must_arrive_to_execute sched'.

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

1 subgoal (ID 2070)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  jobs_must_arrive_to_execute sched'

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

  Proof.
    move⇒ j t.

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

1 subgoal (ID 2073)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  ============================
  scheduled_at sched' j t -> has_arrived j t

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

    rewrite /has_arrived /sched' /make_edf_at.

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

1 subgoal (ID 2086)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  ============================
  scheduled_at
    match sched t_edf with
    | Some j0 => swapped sched t_edf (find_swap_candidate sched t_edf j0)
    | None => sched
    end j t -> job_arrival j <= t

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED_orig;
      last by move⇒ SCHED; by apply H_jobs_must_arrive_to_execute.

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

1 subgoal (ID 2099)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j t -> job_arrival j <= t

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

    have SCHED': scheduled_at sched j_orig t_edf
      by rewrite scheduled_at_def; apply /eqP.

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

1 subgoal (ID 2171)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j t -> job_arrival j <= t

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

    move: (scheduled_job_in_sched_has_later_deadline j_orig t_edf SCHED') ⇒ DL_orig.

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

1 subgoal (ID 2173)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j t -> job_arrival j <= t

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

    rewrite scheduled_at_def /swapped /replace_at.

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

1 subgoal (ID 2186)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  ============================
  (if find_swap_candidate sched t_edf j_orig == t
   then sched t_edf
   else
    if t_edf == t
    then sched (find_swap_candidate sched t_edf j_orig)
    else sched t) == Some j -> job_arrival j <= t

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

    case: (boolP((find_swap_candidate sched t_edf j_orig) == t)) ⇒ [/eqP EQ| /eqP NEQ].

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

2 subgoals (ID 2344)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  EQ : find_swap_candidate sched t_edf j_orig = t
  ============================
  sched t_edf == Some j -> job_arrival j <= t

subgoal 2 (ID 2345) is:
 (if t_edf == t
  then sched (find_swap_candidate sched t_edf j_orig)
  else sched t) == Some j -> job_arrival j <= t

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

    - rewrite SCHED_orig ⇒ /eqP j_is_orig.

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

2 subgoals (ID 2409)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  EQ : find_swap_candidate sched t_edf j_orig = t
  j_is_orig : Some j_orig = Some j
  ============================
  job_arrival j <= t

subgoal 2 (ID 2345) is:
 (if t_edf == t
  then sched (find_swap_candidate sched t_edf j_orig)
  else sched t) == Some j -> job_arrival j <= t

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

      injection j_is_orig ⇒ <-.

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

2 subgoals (ID 2415)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  EQ : find_swap_candidate sched t_edf j_orig = t
  j_is_orig : Some j_orig = Some j
  ============================
  job_arrival j_orig <= t

subgoal 2 (ID 2345) is:
 (if t_edf == t
  then sched (find_swap_candidate sched t_edf j_orig)
  else sched t) == Some j -> job_arrival j <= t

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

      apply leq_trans with (n := t_edf).

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

3 subgoals (ID 2416)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  EQ : find_swap_candidate sched t_edf j_orig = t
  j_is_orig : Some j_orig = Some j
  ============================
  job_arrival j_orig <= t_edf

subgoal 2 (ID 2417) is:
 t_edf <= t
subgoal 3 (ID 2345) is:
 (if t_edf == t
  then sched (find_swap_candidate sched t_edf j_orig)
  else sched t) == Some j -> job_arrival j <= t

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

      + by apply H_jobs_must_arrive_to_execute.

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

2 subgoals (ID 2417)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  EQ : find_swap_candidate sched t_edf j_orig = t
  j_is_orig : Some j_orig = Some j
  ============================
  t_edf <= t

subgoal 2 (ID 2345) is:
 (if t_edf == t
  then sched (find_swap_candidate sched t_edf j_orig)
  else sched t) == Some j -> job_arrival j <= t

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

      + by rewrite -EQ; apply fsc_range1.

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

1 subgoal (ID 2345)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  ============================
  (if t_edf == t
   then sched (find_swap_candidate sched t_edf j_orig)
   else sched t) == Some j -> job_arrival j <= t

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

    - case (boolP(t_edf == t)) ⇒ [/eqP EQ'| /eqP NEQ'].

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

2 subgoals (ID 2567)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  EQ' : t_edf = t
  ============================
  sched (find_swap_candidate sched t_edf j_orig) == Some j ->
  job_arrival j <= t

subgoal 2 (ID 2568) is:
 sched t == Some j -> job_arrival j <= t

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

      + move⇒ SCHED_j.

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

2 subgoals (ID 2569)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  EQ' : t_edf = t
  SCHED_j : sched (find_swap_candidate sched t_edf j_orig) == Some j
  ============================
  job_arrival j <= t

subgoal 2 (ID 2568) is:
 sched t == Some j -> job_arrival j <= t

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

        have ARR_j: job_arrival j ≤ t_edf by apply fsc_found_job_arrival with (sched0 := sched) (j1 := j_orig) ⇒ //; rewrite scheduled_at_def.

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

2 subgoals (ID 2611)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  EQ' : t_edf = t
  SCHED_j : sched (find_swap_candidate sched t_edf j_orig) == Some j
  ARR_j : job_arrival j <= t_edf
  ============================
  job_arrival j <= t

subgoal 2 (ID 2568) is:
 sched t == Some j -> job_arrival j <= t

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

        now rewrite -EQ'.

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

1 subgoal (ID 2568)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  NEQ' : t_edf <> t
  ============================
  sched t == Some j -> job_arrival j <= t

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

      + move⇒ SCHED_j.

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

1 subgoal (ID 2614)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  NEQ' : t_edf <> t
  SCHED_j : sched t == Some j
  ============================
  job_arrival j <= t

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

        apply H_jobs_must_arrive_to_execute.

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

1 subgoal (ID 2615)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED' : scheduled_at sched j_orig t_edf
  DL_orig : t_edf < job_deadline j_orig
  NEQ : find_swap_candidate sched t_edf j_orig <> t
  NEQ' : t_edf <> t
  SCHED_j : sched t == Some j
  ============================
  scheduled_at sched j t

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

        now rewrite scheduled_at_def /scheduled_in /pstate_instance.

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

No more subgoals.

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

  Qed.

We connect the fact that a job is scheduled in [sched'] to the fact that it must be scheduled somewhere in [sched], too, since [make_edf_at] does not introduce any new jobs.
  Lemma mea_job_scheduled:
    ∀ j t,
      scheduled_at sched' j t →
      ∃ t', scheduled_at sched j t'.

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

1 subgoal (ID 2083)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched' j t -> exists t' : instant, scheduled_at sched j t'

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

  Proof.
    rewrite /sched' /make_edf_at.

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

1 subgoal (ID 2091)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at
    match sched t_edf with
    | Some j0 => swapped sched t_edf (find_swap_candidate sched t_edf j0)
    | None => sched
    end j t -> exists t' : instant, scheduled_at sched j t'

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

    move⇒ j t SCHED_j.

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

1 subgoal (ID 2094)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at
              match sched t_edf with
              | Some j =>
                  swapped sched t_edf (find_swap_candidate sched t_edf j)
              | None => sched
              end j t
  ============================
  exists t' : instant, scheduled_at sched j t'

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED_orig; last by ∃ t.

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

1 subgoal (ID 2110)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  ============================
  exists t' : instant, scheduled_at sched j t'

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

    eapply swap_job_scheduled.

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

1 focused subgoal
(shelved: 3) (ID 2121)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  ============================
  scheduled_at (swapped sched ?t1 ?t2) j ?t

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

    now exact SCHED_j.

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

No more subgoals.

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

  Qed.

Conversely, if a job is scheduled in [sched], it is also scheduled somewhere in [sched'] since [make_edf_at] does not lose any jobs.
  Lemma mea_job_scheduled':
    ∀ j t,
      scheduled_at sched j t →
      ∃ t', scheduled_at sched' j t'.

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

1 subgoal (ID 2096)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched j t -> exists t' : instant, scheduled_at sched' j t'

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

  Proof.
    move⇒ j t SCHED_j.

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

1 subgoal (ID 2099)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  ============================
  exists t' : instant, scheduled_at sched' j t'

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

    rewrite /sched' /make_edf_at.

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

1 subgoal (ID 2107)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  ============================
  exists t' : instant,
    scheduled_at
      match sched t_edf with
      | Some j0 => swapped sched t_edf (find_swap_candidate sched t_edf j0)
      | None => sched
      end j t'

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED_orig;
      last by ∃ t.

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

1 subgoal (ID 2120)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  ============================
  exists t' : instant,
    scheduled_at
      (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j t'

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

    eapply swap_job_scheduled_original.

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

1 focused subgoal
(shelved: 1) (ID 2128)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  ============================
  scheduled_at sched j ?t

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

    now exact SCHED_j.

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

No more subgoals.

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

  Qed.

Next, we observe that if all jobs in [sched] come from a given arrival sequence, then that's still the case in [sched'], too.
  Section ArrivalSequence.

For given arrival sequence,...
    Variable arr_seq: arrival_sequence Job.

...if all jobs in [sched] come from the arrival sequence,...
    Hypothesis H_from_arr_seq: jobs_come_from_arrival_sequence sched arr_seq.

...then all jobs in [sched'] do, too.
    Lemma mea_jobs_come_from_arrival_sequence:
      jobs_come_from_arrival_sequence sched' arr_seq.

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

1 subgoal (ID 2103)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence sched' arr_seq

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

    Proof.
      rewrite /sched' /make_edf_at.

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

1 subgoal (ID 2111)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence
    match sched t_edf with
    | Some j => swapped sched t_edf (find_swap_candidate sched t_edf j)
    | None => sched
    end arr_seq

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

      destruct (sched t_edf) as [j_orig|] eqn:SCHED_orig;
        last by done.

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

1 subgoal (ID 2124)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  j_orig : Job
  SCHED_orig : sched t_edf = Some j_orig
  ============================
  jobs_come_from_arrival_sequence
    (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) arr_seq

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

      now apply swapped_jobs_come_from_arrival_sequence.

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

No more subgoals.

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

    Qed.

  End ArrivalSequence.

For the final claim, assume that [EDF_at] already holds everywhere prior to time [t_edf], i.e., that [sched] consists of an EDF prefix.
  Hypothesis H_EDF_prefix: ∀ t, t < t_edf → EDF_at sched t.

We establish a key property of [make_edf_at]: not only does it ensure [EDF_at] at time [t_edf], it also maintains the fact that the schedule has an EDF prefix prior to time [t_edf]. In other words, it grows the EDF prefix by one time unit.
  Lemma mea_EDF_widen:
    ∀ t, t ≤ t_edf → EDF_at sched' t.

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

1 subgoal (ID 2111)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  ============================
  forall t : nat, t <= t_edf -> EDF_at sched' t

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

  Proof.
    move⇒ t.

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

1 subgoal (ID 2112)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  ============================
  t <= t_edf -> EDF_at sched' t

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

    rewrite leq_eqVlt ⇒ /orP [/eqP EQ|LT] ;
      first by rewrite EQ; apply make_edf_at_guarantee.

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

1 subgoal (ID 2244)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  ============================
  EDF_at sched' t

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

    rewrite /sched' /make_edf_at.

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

1 subgoal (ID 2254)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  ============================
  EDF_at
    match sched t_edf with
    | Some j => swapped sched t_edf (find_swap_candidate sched t_edf j)
    | None => sched
    end t

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

    destruct (sched t_edf) as [j_orig|] eqn:SCHED_edf; last by apply H_EDF_prefix.

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

1 subgoal (ID 2267)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  ============================
  EDF_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) t

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

    move⇒ j SCHED_j t' j' LE_t_t' SCHED_j' ARR_j'.

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

1 subgoal (ID 2277)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  ============================
  job_deadline j <= job_deadline j'

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

    have SCHED_edf': scheduled_at sched j_orig t_edf
      by rewrite scheduled_at_def; apply /eqP.

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

1 subgoal (ID 2346)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  ============================
  job_deadline j <= job_deadline j'

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

    have LT_t_fsc: t < find_swap_candidate sched t_edf j_orig.

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

2 subgoals (ID 2350)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  ============================
  t < find_swap_candidate sched t_edf j_orig

subgoal 2 (ID 2352) is:
 job_deadline j <= job_deadline j'

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

    {

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

1 subgoal (ID 2350)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  ============================
  t < find_swap_candidate sched t_edf j_orig

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

      apply ltn_leq_trans with (n := t_edf) ⇒ //.

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

1 subgoal (ID 2354)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  ============================
  t_edf <= find_swap_candidate sched t_edf j_orig

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

      apply fsc_range1 ⇒ //.

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

1 subgoal (ID 2382)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  ============================
  t_edf < job_deadline j_orig

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

      now apply scheduled_job_in_sched_has_later_deadline.

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

1 subgoal (ID 2352)

subgoal 1 (ID 2352) is:
 job_deadline j <= job_deadline j'

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

    }

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

1 subgoal (ID 2352)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  SCHED_j : scheduled_at
              (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
              j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  ============================
  job_deadline j <= job_deadline j'

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

    move: SCHED_j.

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

1 subgoal (ID 2407)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j t -> job_deadline j <= job_deadline j'

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

    have ->: scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig)) j t = scheduled_at sched j t
      by apply swap_job_scheduled_other_times; [move: LT | move: LT_t_fsc]; rewrite ltn_neqAle ⇒ /andP [NEQ _]; rewrite eq_sym.

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

1 subgoal (ID 2580)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  ============================
  scheduled_at sched j t -> job_deadline j <= job_deadline j'

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

    move ⇒ SCHED_j.

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

1 subgoal (ID 2581)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  ============================
  job_deadline j <= job_deadline j'

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

    move: (H_EDF_prefix t LT).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2582)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  ============================
  EDF_at sched t -> job_deadline j <= job_deadline j'

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

rewrite /EDF_at ⇒ EDF.

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

1 subgoal (ID 2594)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  EDF : forall j : Job,
        scheduled_at sched j t ->
        forall (t' : instant) (j' : Job),
        t <= t' ->
        scheduled_at sched j' t' ->
        job_arrival j' <= t -> job_deadline j <= job_deadline j'
  ============================
  job_deadline j <= job_deadline j'

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

    move: (SCHED_j').

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

1 subgoal (ID 2595)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  EDF : forall j : Job,
        scheduled_at sched j t ->
        forall (t' : instant) (j' : Job),
        t <= t' ->
        scheduled_at sched j' t' ->
        job_arrival j' <= t -> job_deadline j <= job_deadline j'
  ============================
  scheduled_at (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
    j' t' -> job_deadline j <= job_deadline j'

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

    move: (swap_job_scheduled_cases _ _ _ _ _ SCHED_j') ⇒ [->|[[EQ ->]|[EQ ->]]] SCHED_j'_orig.

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

3 subgoals (ID 2666)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  EDF : forall j : Job,
        scheduled_at sched j t ->
        forall (t' : instant) (j' : Job),
        t <= t' ->
        scheduled_at sched j' t' ->
        job_arrival j' <= t -> job_deadline j <= job_deadline j'
  SCHED_j'_orig : scheduled_at sched j' t'
  ============================
  job_deadline j <= job_deadline j'

subgoal 2 (ID 2667) is:
 job_deadline j <= job_deadline j'
subgoal 3 (ID 2668) is:
 job_deadline j <= job_deadline j'

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

    - by apply EDF with (t' := t').

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

2 subgoals (ID 2667)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  EDF : forall j : Job,
        scheduled_at sched j t ->
        forall (t' : instant) (j' : Job),
        t <= t' ->
        scheduled_at sched j' t' ->
        job_arrival j' <= t -> job_deadline j <= job_deadline j'
  EQ : t' = t_edf
  SCHED_j'_orig : scheduled_at sched j'
                    (find_swap_candidate sched t_edf j_orig)
  ============================
  job_deadline j <= job_deadline j'

subgoal 2 (ID 2668) is:
 job_deadline j <= job_deadline j'

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

    - by apply EDF with (t' := (find_swap_candidate sched t_edf j_orig)) ⇒ //; apply ltnW.

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

1 subgoal (ID 2668)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  t_edf : instant
  sched' := make_edf_at sched t_edf : schedule (processor_state Job)
  H_EDF_prefix : forall t : nat, t < t_edf -> EDF_at sched t
  t : nat
  LT : t < t_edf
  j_orig : Job
  SCHED_edf : sched t_edf = Some j_orig
  j : Job
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at
               (swapped sched t_edf (find_swap_candidate sched t_edf j_orig))
               j' t'
  ARR_j' : job_arrival j' <= t
  SCHED_edf' : scheduled_at sched j_orig t_edf
  LT_t_fsc : t < find_swap_candidate sched t_edf j_orig
  SCHED_j : scheduled_at sched j t
  EDF : forall j : Job,
        scheduled_at sched j t ->
        forall (t' : instant) (j' : Job),
        t <= t' ->
        scheduled_at sched j' t' ->
        job_arrival j' <= t -> job_deadline j <= job_deadline j'
  EQ : t' = find_swap_candidate sched t_edf j_orig
  SCHED_j'_orig : scheduled_at sched j' t_edf
  ============================
  job_deadline j <= job_deadline j'

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

    - by apply EDF with (t' := t_edf) ⇒ //; apply ltnW.

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

No more subgoals.

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

  Qed.

End MakeEDFAtFacts.

In the following section, we establish properties of [edf_transform_prefix].
Section EDFPrefixFacts.

For any given type of jobs...
  Context {Job : JobType} `{JobCost Job} `{JobDeadline Job} `{JobArrival Job}.

...consider an ideal uniprocessor schedule...
  Variable sched: schedule (ideal.processor_state Job).

...that is well-behaved...
  Hypothesis H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute sched.
  Hypothesis H_completed_jobs_dont_execute: completed_jobs_dont_execute sched.

...and in which no scheduled job misses a deadline.
  Hypothesis H_no_deadline_misses: all_deadlines_met sched.

Consider any point in time, denoted [horizon], and...
  Variable horizon: instant.

...let [sched'] denote the schedule obtained by transforming [sched] up to the horizon.
  Let sched' := edf_transform_prefix sched horizon.

To start, we observe that [sched'] is still well-behaved and without deadline misses.
  Lemma edf_prefix_well_formedness:
    completed_jobs_dont_execute sched'
    ∧
    jobs_must_arrive_to_execute sched'
    ∧
    all_deadlines_met sched'.

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

1 subgoal (ID 2041)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  completed_jobs_dont_execute sched' /\
  jobs_must_arrive_to_execute sched' /\ all_deadlines_met sched'

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

  Proof.
    rewrite /sched' /edf_transform_prefix.

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

1 subgoal (ID 2049)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  completed_jobs_dont_execute (prefix_map sched make_edf_at horizon) /\
  jobs_must_arrive_to_execute (prefix_map sched make_edf_at horizon) /\
  all_deadlines_met (prefix_map sched make_edf_at horizon)

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

    apply prefix_map_property_invariance; last by split.

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

1 subgoal (ID 2051)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t : instant),
  completed_jobs_dont_execute sched0 /\
  jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
  completed_jobs_dont_execute (make_edf_at sched0 t) /\
  jobs_must_arrive_to_execute (make_edf_at sched0 t) /\
  all_deadlines_met (make_edf_at sched0 t)

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

    move⇒ sched'' t [COMP [ARR DL_MET]].

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

1 subgoal (ID 2106)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  sched'' : schedule (option_eqType Job)
  t : instant
  COMP : completed_jobs_dont_execute sched''
  ARR : jobs_must_arrive_to_execute sched''
  DL_MET : all_deadlines_met sched''
  ============================
  completed_jobs_dont_execute (make_edf_at sched'' t) /\
  jobs_must_arrive_to_execute (make_edf_at sched'' t) /\
  all_deadlines_met (make_edf_at sched'' t)

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

    split; last split.

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

3 subgoals (ID 2108)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  sched'' : schedule (option_eqType Job)
  t : instant
  COMP : completed_jobs_dont_execute sched''
  ARR : jobs_must_arrive_to_execute sched''
  DL_MET : all_deadlines_met sched''
  ============================
  completed_jobs_dont_execute (make_edf_at sched'' t)

subgoal 2 (ID 2111) is:
 jobs_must_arrive_to_execute (make_edf_at sched'' t)
subgoal 3 (ID 2112) is:
 all_deadlines_met (make_edf_at sched'' t)

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

    - apply mea_completed_jobs ⇒ //.

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

2 subgoals (ID 2111)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  sched'' : schedule (option_eqType Job)
  t : instant
  COMP : completed_jobs_dont_execute sched''
  ARR : jobs_must_arrive_to_execute sched''
  DL_MET : all_deadlines_met sched''
  ============================
  jobs_must_arrive_to_execute (make_edf_at sched'' t)

subgoal 2 (ID 2112) is:
 all_deadlines_met (make_edf_at sched'' t)

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

    - apply mea_jobs_must_arrive ⇒ //.

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

1 subgoal (ID 2112)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  sched'' : schedule (option_eqType Job)
  t : instant
  COMP : completed_jobs_dont_execute sched''
  ARR : jobs_must_arrive_to_execute sched''
  DL_MET : all_deadlines_met sched''
  ============================
  all_deadlines_met (make_edf_at sched'' t)

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

    - apply mea_no_deadline_misses ⇒ //.

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

No more subgoals.

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

  Qed.

Because it is needed frequently, we extract the second clause of the above conjunction as a corollary.
  Corollary edf_prefix_jobs_must_arrive:
    jobs_must_arrive_to_execute sched'.

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

1 subgoal (ID 2046)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  jobs_must_arrive_to_execute sched'

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

  Proof. by move: edf_prefix_well_formedness ⇒ [_ [ARR _]].
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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

Qed.

We similarly observe that the absence of deadline misses implies that any scheduled job must have a deadline at a time later then when it is scheduled.
  Corollary edf_prefix_scheduled_job_has_later_deadline:
    ∀ j t,
      scheduled_at sched' j t →
      job_deadline j > t.

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

1 subgoal (ID 2056)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched' j t -> t < job_deadline j

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

  Proof.
    move⇒ j t SCHED.

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

1 subgoal (ID 2059)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  ============================
  t < job_deadline j

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

    move: edf_prefix_well_formedness ⇒ [COMP [ARR DL_MET]].

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

1 subgoal (ID 2081)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  COMP : completed_jobs_dont_execute sched'
  ARR : jobs_must_arrive_to_execute sched'
  DL_MET : all_deadlines_met sched'
  ============================
  t < job_deadline j

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

    apply (scheduled_at_implies_later_deadline sched') ⇒ //.

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

2 subgoals (ID 2089)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  COMP : completed_jobs_dont_execute sched'
  ARR : jobs_must_arrive_to_execute sched'
  DL_MET : all_deadlines_met sched'
  ============================
  ideal_progress_proc_model (option_eqType Job)

subgoal 2 (ID 2090) is:
 job_meets_deadline sched' j

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

    - by apply ideal_proc_model_ensures_ideal_progress.

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

1 subgoal (ID 2090)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED : scheduled_at sched' j t
  COMP : completed_jobs_dont_execute sched'
  ARR : jobs_must_arrive_to_execute sched'
  DL_MET : all_deadlines_met sched'
  ============================
  job_meets_deadline sched' j

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

    - by apply (DL_MET j t).

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

No more subgoals.

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

  Qed.

Since no jobs are lost or added to the schedule by [edf_transform_prefix], we if a job is scheduled in the transformed schedule, then it is also scheduled at some point in the original schedule.
  Lemma edf_prefix_job_scheduled:
    ∀ j t,
      scheduled_at sched' j t →
      ∃ t', scheduled_at sched j t'.

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

1 subgoal (ID 2069)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched' j t -> exists t' : instant, scheduled_at sched j t'

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

  Proof.
    rewrite /sched' /edf_transform_prefix.

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

1 subgoal (ID 2077)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at (prefix_map sched make_edf_at horizon) j t ->
  exists t' : instant, scheduled_at sched j t'

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

    move⇒ j.

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

1 subgoal (ID 2078)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  ============================
  forall t : instant,
  scheduled_at (prefix_map sched make_edf_at horizon) j t ->
  exists t' : instant, scheduled_at sched j t'

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

    apply prefix_map_property_invariance;
      last by move⇒ t SCHED; ∃ t.

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

1 subgoal (ID 2080)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t : instant),
  (forall t0 : instant,
   scheduled_at sched0 j t0 -> exists t' : instant, scheduled_at sched j t') ->
  forall t0 : instant,
  scheduled_at (make_edf_at sched0 t) j t0 ->
  exists t' : instant, scheduled_at sched j t'

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

    move⇒ sched'' t'' EX t''' SCHED_mea.

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

1 subgoal (ID 2090)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  sched'' : schedule (option_eqType Job)
  t'' : instant
  EX : forall t : instant,
       scheduled_at sched'' j t ->
       exists t' : instant, scheduled_at sched j t'
  t''' : instant
  SCHED_mea : scheduled_at (make_edf_at sched'' t'') j t'''
  ============================
  exists t' : instant, scheduled_at sched j t'

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

    move: (mea_job_scheduled _ _ _ _ SCHED_mea) ⇒ [t'''' SCHED''''].

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

1 subgoal (ID 2113)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  sched'' : schedule (option_eqType Job)
  t'' : instant
  EX : forall t : instant,
       scheduled_at sched'' j t ->
       exists t' : instant, scheduled_at sched j t'
  t''' : instant
  SCHED_mea : scheduled_at (make_edf_at sched'' t'') j t'''
  t'''' : instant
  SCHED'''' : scheduled_at sched'' j t''''
  ============================
  exists t' : instant, scheduled_at sched j t'

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

    now apply: (EX t'''' SCHED'''').

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

No more subgoals.

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

  Qed.

Conversely, if a job is scheduled in the original schedule, it is also scheduled at some point in the transformed schedule.
  Lemma edf_prefix_job_scheduled':
    ∀ j t,
      scheduled_at sched j t →
      ∃ t', scheduled_at sched' j t'.

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

1 subgoal (ID 2082)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched j t -> exists t' : instant, scheduled_at sched' j t'

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

  Proof.
    move⇒ j t SCHED_j.

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

1 subgoal (ID 2085)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  ============================
  exists t' : instant, scheduled_at sched' j t'

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

    rewrite /sched' /edf_transform_prefix.

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

1 subgoal (ID 2093)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  ============================
  exists t' : instant,
    scheduled_at (prefix_map sched make_edf_at horizon) j t'

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

    apply prefix_map_property_invariance; last by ∃ t.

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

1 subgoal (ID 2095)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t0 : instant),
  (exists t' : instant, scheduled_at sched0 j t') ->
  exists t' : instant, scheduled_at (make_edf_at sched0 t0) j t'

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

    move⇒ schedX tx [t' SCHEDX_j].

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

1 subgoal (ID 2111)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  schedX : schedule (option_eqType Job)
  tx, t' : instant
  SCHEDX_j : scheduled_at schedX j t'
  ============================
  exists t'0 : instant, scheduled_at (make_edf_at schedX tx) j t'0

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

    eapply mea_job_scheduled'.

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

1 focused subgoal
(shelved: 1) (ID 2116)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  schedX : schedule (option_eqType Job)
  tx, t' : instant
  SCHEDX_j : scheduled_at schedX j t'
  ============================
  scheduled_at schedX j ?t

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

    now exact SCHEDX_j.

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

No more subgoals.

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

  Qed.

Next, we note that [edf_transform_prefix] maintains the property that all jobs stem from a given arrival sequence.
  Section ArrivalSequence.

For any arrival sequence,...
    Variable arr_seq: arrival_sequence Job.

...if all jobs in the original schedule come from the arrival sequence,...
    Hypothesis H_from_arr_seq: jobs_come_from_arrival_sequence sched arr_seq.

...then all jobs in the transformed schedule still come from the same arrival sequence.
    Lemma edf_prefix_jobs_come_from_arrival_sequence:
      jobs_come_from_arrival_sequence sched' arr_seq.

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

1 subgoal (ID 2089)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence sched' arr_seq

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

    Proof.
      rewrite /sched' /edf_transform_prefix.

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

1 subgoal (ID 2097)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence (prefix_map sched make_edf_at horizon)
    arr_seq

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

      apply prefix_map_property_invariance; last by done.

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

1 subgoal (ID 2099)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t : instant),
  jobs_come_from_arrival_sequence sched0 arr_seq ->
  jobs_come_from_arrival_sequence (make_edf_at sched0 t) arr_seq

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

      move ⇒ schedX t ARR.

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

1 subgoal (ID 2103)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  schedX : schedule (option_eqType Job)
  t : instant
  ARR : jobs_come_from_arrival_sequence schedX arr_seq
  ============================
  jobs_come_from_arrival_sequence (make_edf_at schedX t) arr_seq

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

      now apply mea_jobs_come_from_arrival_sequence.

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

No more subgoals.

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

    Qed.

  End ArrivalSequence.

We establish the key property of [edf_transform_prefix]: that it indeed ensures that the resulting schedule ensures the EDF invariant up to the given [horizon].
  Lemma edf_prefix_guarantee:
    ∀ t,
      t < horizon →
      EDF_at sched' t.

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

1 subgoal (ID 2090)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  ============================
  forall t : nat, t < horizon -> EDF_at sched' t

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

  Proof.
    move⇒ t IN_PREFIX.

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

1 subgoal (ID 2092)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  ============================
  EDF_at sched' t

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

    rewrite /sched' /edf_transform_prefix.

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

1 subgoal (ID 2100)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  ============================
  EDF_at (prefix_map sched make_edf_at horizon) t

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

    apply prefix_map_pointwise_property
      with (Q := EDF_at)
           (P := (fun sched ⇒ completed_jobs_dont_execute sched
                               ∧
                               jobs_must_arrive_to_execute sched
                               ∧
                               all_deadlines_met sched))=> //.

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

2 subgoals (ID 2124)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t_ref : instant),
  completed_jobs_dont_execute sched0 /\
  jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
  completed_jobs_dont_execute (make_edf_at sched0 t_ref) /\
  jobs_must_arrive_to_execute (make_edf_at sched0 t_ref) /\
  all_deadlines_met (make_edf_at sched0 t_ref)

subgoal 2 (ID 2125) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 completed_jobs_dont_execute sched0 /\
 jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
 (forall t' : nat, t' < t_ref -> EDF_at sched0 t') ->
 forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at sched0 t_ref) t'

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

    - move⇒ schedX t_ref [COMP [ARR DL]].

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

2 subgoals (ID 2412)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  schedX : schedule (option_eqType Job)
  t_ref : instant
  COMP : completed_jobs_dont_execute schedX
  ARR : jobs_must_arrive_to_execute schedX
  DL : all_deadlines_met schedX
  ============================
  completed_jobs_dont_execute (make_edf_at schedX t_ref) /\
  jobs_must_arrive_to_execute (make_edf_at schedX t_ref) /\
  all_deadlines_met (make_edf_at schedX t_ref)

subgoal 2 (ID 2125) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 completed_jobs_dont_execute sched0 /\
 jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
 (forall t' : nat, t' < t_ref -> EDF_at sched0 t') ->
 forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at sched0 t_ref) t'

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

      split; last split.

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

4 subgoals (ID 2414)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  schedX : schedule (option_eqType Job)
  t_ref : instant
  COMP : completed_jobs_dont_execute schedX
  ARR : jobs_must_arrive_to_execute schedX
  DL : all_deadlines_met schedX
  ============================
  completed_jobs_dont_execute (make_edf_at schedX t_ref)

subgoal 2 (ID 2417) is:
 jobs_must_arrive_to_execute (make_edf_at schedX t_ref)
subgoal 3 (ID 2418) is:
 all_deadlines_met (make_edf_at schedX t_ref)
subgoal 4 (ID 2125) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 completed_jobs_dont_execute sched0 /\
 jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
 (forall t' : nat, t' < t_ref -> EDF_at sched0 t') ->
 forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at sched0 t_ref) t'

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

      + by apply mea_completed_jobs ⇒ //.

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

3 subgoals (ID 2417)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  schedX : schedule (option_eqType Job)
  t_ref : instant
  COMP : completed_jobs_dont_execute schedX
  ARR : jobs_must_arrive_to_execute schedX
  DL : all_deadlines_met schedX
  ============================
  jobs_must_arrive_to_execute (make_edf_at schedX t_ref)

subgoal 2 (ID 2418) is:
 all_deadlines_met (make_edf_at schedX t_ref)
subgoal 3 (ID 2125) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 completed_jobs_dont_execute sched0 /\
 jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
 (forall t' : nat, t' < t_ref -> EDF_at sched0 t') ->
 forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at sched0 t_ref) t'

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

      + by apply mea_jobs_must_arrive ⇒ //.

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

2 subgoals (ID 2418)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  schedX : schedule (option_eqType Job)
  t_ref : instant
  COMP : completed_jobs_dont_execute schedX
  ARR : jobs_must_arrive_to_execute schedX
  DL : all_deadlines_met schedX
  ============================
  all_deadlines_met (make_edf_at schedX t_ref)

subgoal 2 (ID 2125) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 completed_jobs_dont_execute sched0 /\
 jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
 (forall t' : nat, t' < t_ref -> EDF_at sched0 t') ->
 forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at sched0 t_ref) t'

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

      + by apply mea_no_deadline_misses ⇒ //.

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

1 subgoal (ID 2125)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
  completed_jobs_dont_execute sched0 /\
  jobs_must_arrive_to_execute sched0 /\ all_deadlines_met sched0 ->
  (forall t' : nat, t' < t_ref -> EDF_at sched0 t') ->
  forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at sched0 t_ref) t'

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

    - move⇒ schedX t_ref [COMP [ARR DL]].

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

1 subgoal (ID 2462)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  horizon : instant
  sched' := edf_transform_prefix sched horizon
   : schedule (processor_state Job)
  t : nat
  IN_PREFIX : t < horizon
  schedX : schedule (option_eqType Job)
  t_ref : nat
  COMP : completed_jobs_dont_execute schedX
  ARR : jobs_must_arrive_to_execute schedX
  DL : all_deadlines_met schedX
  ============================
  (forall t' : nat, t' < t_ref -> EDF_at schedX t') ->
  forall t' : nat, t' <= t_ref -> EDF_at (make_edf_at schedX t_ref) t'

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

      now apply mea_EDF_widen.

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

No more subgoals.

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

  Qed.

End EDFPrefixFacts.

Finally, we observe that [edf_transform_prefix] is prefix-stable, which allows us to replace an earlier horizon with a later horizon. Note: this is in a separate section because we need [edf_prefix_jobs_must_arrive] generalized for any schedule.
Section EDFPrefixInclusion.

For any given type of jobs...
  Context {Job : JobType} `{JobCost Job} `{JobDeadline Job} `{JobArrival Job}.

...consider an ideal uniprocessor schedule...
  Variable sched: schedule (ideal.processor_state Job).

...that is well-behaved...
  Hypothesis H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute sched.
  Hypothesis H_completed_jobs_dont_execute: completed_jobs_dont_execute sched.

...and in which no scheduled job misses a deadline.
  Hypothesis H_no_deadline_misses: all_deadlines_met sched.

  Lemma edf_prefix_inclusion:
    ∀ h1 h2,
      h1 ≤ h2 →
      identical_prefix (edf_transform_prefix sched h1) (edf_transform_prefix sched h2) h1.

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

1 subgoal (ID 2033)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  ============================
  forall h1 h2 : nat,
  h1 <= h2 ->
  identical_prefix (edf_transform_prefix sched h1)
    (edf_transform_prefix sched h2) h1

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

  Proof.
    move⇒ h1 h2 LE_h1_h2.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2036)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2 : nat
  LE_h1_h2 : h1 <= h2
  ============================
  identical_prefix (edf_transform_prefix sched h1)
    (edf_transform_prefix sched h2) h1

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

rewrite /identical_prefix ⇒ t LT_t_h1.

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

1 subgoal (ID 2041)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2 : nat
  LE_h1_h2 : h1 <= h2
  t : nat
  LT_t_h1 : t < h1
  ============================
  edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t

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

    induction h2; first by move: (ltn_leq_trans LT_t_h1 LE_h1_h2).

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

1 subgoal (ID 2056)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2 : nat
  LE_h1_h2 : h1 <= succn h2
  t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  ============================
  edf_transform_prefix sched h1 t = edf_transform_prefix sched (succn h2) t

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

    move: LE_h1_h2.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2086)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  ============================
  h1 <= succn h2 ->
  edf_transform_prefix sched h1 t = edf_transform_prefix sched (succn h2) t

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

rewrite leq_eqVlt ⇒ /orP [/eqP ->|LT]; first by done.

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

1 subgoal (ID 2221)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LT : h1 < succn h2
  ============================
  edf_transform_prefix sched h1 t = edf_transform_prefix sched (succn h2) t

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

    move: LT.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2223)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  ============================
  h1 < succn h2 ->
  edf_transform_prefix sched h1 t = edf_transform_prefix sched (succn h2) t

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

rewrite ltnS ⇒ LE_h1_h2.

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

1 subgoal (ID 2228)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  ============================
  edf_transform_prefix sched h1 t = edf_transform_prefix sched (succn h2) t

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

    rewrite [RHS]/edf_transform_prefix /prefix_map -/prefix_map IHh2 //.

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

1 subgoal (ID 2252)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  ============================
  edf_transform_prefix sched h2 t =
  make_edf_at (prefix_map sched make_edf_at h2) h2 t

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

    rewrite {1}/make_edf_at.

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

1 subgoal (ID 2282)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  ============================
  edf_transform_prefix sched h2 t =
  match prefix_map sched make_edf_at h2 h2 with
  | Some j =>
      swapped (prefix_map sched make_edf_at h2) h2
        (find_swap_candidate (prefix_map sched make_edf_at h2) h2 j)
  | None => prefix_map sched make_edf_at h2
  end t

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

    destruct (prefix_map sched make_edf_at h2 h2) as [j|] eqn:SCHED; last by done.

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

1 subgoal (ID 2300)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  j : Job
  SCHED : prefix_map sched make_edf_at h2 h2 = Some j
  ============================
  edf_transform_prefix sched h2 t =
  swapped (prefix_map sched make_edf_at h2) h2
    (find_swap_candidate (prefix_map sched make_edf_at h2) h2 j) t

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

    rewrite -(swap_before_invariant _ h2 (find_swap_candidate (edf_transform_prefix sched h2) h2 j)) // ;
      last by apply ltn_leq_trans with (n := h1).

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

1 subgoal (ID 2325)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  j : Job
  SCHED : prefix_map sched make_edf_at h2 h2 = Some j
  ============================
  h2 <= find_swap_candidate (edf_transform_prefix sched h2) h2 j

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

    have SCHED_j: scheduled_at (edf_transform_prefix sched h2) j h2
      by rewrite scheduled_at_def /edf_transform_prefix; apply /eqP.

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

1 subgoal (ID 2451)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  j : Job
  SCHED : prefix_map sched make_edf_at h2 h2 = Some j
  SCHED_j : scheduled_at (edf_transform_prefix sched h2) j h2
  ============================
  h2 <= find_swap_candidate (edf_transform_prefix sched h2) h2 j

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

    apply fsc_range1 ⇒ //.

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

2 subgoals (ID 2455)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  j : Job
  SCHED : prefix_map sched make_edf_at h2 h2 = Some j
  SCHED_j : scheduled_at (edf_transform_prefix sched h2) j h2
  ============================
  jobs_must_arrive_to_execute (edf_transform_prefix sched h2)

subgoal 2 (ID 2457) is:
 h2 < job_deadline j

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

    - by apply edf_prefix_jobs_must_arrive.

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

1 subgoal (ID 2457)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  h1, h2, t : nat
  LT_t_h1 : t < h1
  IHh2 : h1 <= h2 ->
         edf_transform_prefix sched h1 t = edf_transform_prefix sched h2 t
  LE_h1_h2 : h1 <= h2
  j : Job
  SCHED : prefix_map sched make_edf_at h2 h2 = Some j
  SCHED_j : scheduled_at (edf_transform_prefix sched h2) j h2
  ============================
  h2 < job_deadline j

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

    - apply edf_prefix_scheduled_job_has_later_deadline with (sched0 := sched) (horizon := h2) ⇒ //.

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

No more subgoals.

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

  Qed.

End EDFPrefixInclusion.

In the following section, we finally establish properties of the overall EDF transformation[edf_transform].
Section EDFTransformFacts.

For any given type of jobs...
  Context {Job : JobType} `{JobCost Job} `{JobDeadline Job} `{JobArrival Job}.

...consider an ideal uniprocessor schedule...
  Variable sched: schedule (ideal.processor_state Job).

...that is well-behaved...
  Hypothesis H_jobs_must_arrive_to_execute: jobs_must_arrive_to_execute sched.
  Hypothesis H_completed_jobs_dont_execute: completed_jobs_dont_execute sched.

...and in which no scheduled job misses a deadline.
  Hypothesis H_no_deadline_misses: all_deadlines_met sched.

In the following, let [sched_edf] denote the EDF schedule obtained by transforming the given reference schedule.
  Let sched_edf := edf_transform sched.

We begin with a simple lemma relating [sched_edf] to its definition that allows us to easily look at any finite prefix of the EDF-transformed scheduled.
  Lemma edf_finite_prefix:
    ∀ h,
      identical_prefix sched_edf (edf_transform_prefix sched h) h.

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

1 subgoal (ID 2032)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  forall h : instant,
  identical_prefix sched_edf (edf_transform_prefix sched h) h

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

  Proof.
    move⇒ h.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2033)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  h : instant
  ============================
  identical_prefix sched_edf (edf_transform_prefix sched h) h

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

rewrite /sched_edf/edf_transform /identical_prefix ⇒ t LT_h.

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

1 subgoal (ID 2046)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  h : instant
  t : nat
  LT_h : t < h
  ============================
  edf_transform_prefix sched (succn t) t = edf_transform_prefix sched h t

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

    now apply edf_prefix_inclusion.

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

No more subgoals.

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

  Qed.

From this, we move on to the defining property of the transformation: the resulting schedule is actually an EDF schedule.
  Theorem edf_transform_ensures_edf:
    EDF_schedule sched_edf.

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

1 subgoal (ID 2039)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  EDF_schedule sched_edf

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

  Proof.
    rewrite /EDF_schedule ⇒ t.

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

1 subgoal (ID 2051)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  t : instant
  ============================
  EDF_at sched_edf t

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

    rewrite /EDF_at //= ⇒ j SCHED_j t' j' LE_t_t' SCHED_j' ARR_j'.

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

1 subgoal (ID 2106)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  t : instant
  j : Job
  SCHED_j : scheduled_at sched_edf j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at sched_edf j' t'
  ARR_j' : job_arrival j' <= t
  ============================
  job_deadline j <= job_deadline j'

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

    set S := (edf_transform_prefix sched t'.+1).

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

1 subgoal (ID 2111)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  t : instant
  j : Job
  SCHED_j : scheduled_at sched_edf j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at sched_edf j' t'
  ARR_j' : job_arrival j' <= t
  S := edf_transform_prefix sched (succn t') : schedule (processor_state Job)
  ============================
  job_deadline j <= job_deadline j'

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

    have EDF: EDF_at S t by apply edf_prefix_guarantee.

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

1 subgoal (ID 2128)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  t : instant
  j : Job
  SCHED_j : scheduled_at sched_edf j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at sched_edf j' t'
  ARR_j' : job_arrival j' <= t
  S := edf_transform_prefix sched (succn t') : schedule (processor_state Job)
  EDF : EDF_at S t
  ============================
  job_deadline j <= job_deadline j'

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

    apply EDF with (t' := t') ⇒ //.

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

1 subgoal (ID 2129)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  t : instant
  j : Job
  SCHED_j : scheduled_at sched_edf j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at sched_edf j' t'
  ARR_j' : job_arrival j' <= t
  S := edf_transform_prefix sched (succn t') : schedule (processor_state Job)
  EDF : EDF_at S t
  ============================
  scheduled_at S j t

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

    rewrite -(identical_prefix_scheduled_at sched_edf _ t'.+1) //.

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

1 subgoal (ID 2171)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  t : instant
  j : Job
  SCHED_j : scheduled_at sched_edf j t
  t' : instant
  j' : Job
  LE_t_t' : t <= t'
  SCHED_j' : scheduled_at sched_edf j' t'
  ARR_j' : job_arrival j' <= t
  S := edf_transform_prefix sched (succn t') : schedule (processor_state Job)
  EDF : EDF_at S t
  ============================
  identical_prefix sched_edf S (succn t')

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

    now apply edf_finite_prefix.

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

No more subgoals.

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

  Qed.

Next, we observe that completed jobs still don't execute in the resulting EDF schedule. This observation is needed to establish that the resulting EDF schedule is valid.
  Lemma edf_transform_completed_jobs_dont_execute:
    completed_jobs_dont_execute sched_edf.

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

1 subgoal (ID 2044)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  completed_jobs_dont_execute sched_edf

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

  Proof.
    move⇒ j t.

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

1 subgoal (ID 2047)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at sched_edf j t -> service sched_edf j t < job_cost j

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

    set S := (edf_transform_prefix sched t.+1).

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

1 subgoal (ID 2052)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  S := edf_transform_prefix sched (succn t) : schedule (processor_state Job)
  ============================
  scheduled_at sched_edf j t -> service sched_edf j t < job_cost j

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

    rewrite (identical_prefix_scheduled_at _ S t.+1) //;
            last by apply edf_finite_prefix.

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

1 subgoal (ID 2068)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  S := edf_transform_prefix sched (succn t) : schedule (processor_state Job)
  ============================
  scheduled_at S j t -> service sched_edf j t < job_cost j

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

    rewrite (identical_prefix_service _ S t) //;
            last by apply (identical_prefix_inclusion _ _ t.+1) ⇒ //; apply edf_finite_prefix.

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

1 subgoal (ID 2132)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  S := edf_transform_prefix sched (succn t) : schedule (processor_state Job)
  ============================
  scheduled_at S j t -> service S j t < job_cost j

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

    move: (edf_prefix_well_formedness sched H_jobs_must_arrive_to_execute
                                      H_completed_jobs_dont_execute H_no_deadline_misses t.+1) ⇒ [COMP _].

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

1 subgoal (ID 2229)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  S := edf_transform_prefix sched (succn t) : schedule (processor_state Job)
  COMP : completed_jobs_dont_execute (edf_transform_prefix sched (succn t))
  ============================
  scheduled_at S j t -> service S j t < job_cost j

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

    now apply COMP.

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

No more subgoals.

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

  Qed.

Similarly, we observe that no job is scheduled prior to its arrival.
  Lemma edf_transform_jobs_must_arrive:
    jobs_must_arrive_to_execute sched_edf.

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

1 subgoal (ID 2049)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  jobs_must_arrive_to_execute sched_edf

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

  Proof.
    move⇒ j t.

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

1 subgoal (ID 2052)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at sched_edf j t -> has_arrived j t

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

    rewrite /sched_edf /edf_transform.

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

1 subgoal (ID 2060)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at (fun t0 : instant => edf_transform_prefix sched (succn t0) t0)
    j t -> has_arrived j t

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

    move: (edf_prefix_well_formedness sched H_jobs_must_arrive_to_execute H_completed_jobs_dont_execute H_no_deadline_misses t.+1) ⇒ [_ [ARR _]].

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

1 subgoal (ID 2087)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ARR : jobs_must_arrive_to_execute (edf_transform_prefix sched (succn t))
  ============================
  scheduled_at (fun t0 : instant => edf_transform_prefix sched (succn t0) t0)
    j t -> has_arrived j t

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

    now apply ARR.

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

No more subgoals.

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

  Qed.

We next establish the second key property: in the transformed EDF schedule, no scheduled job misses a deadline.
  Theorem edf_transform_deadlines_met:
    all_deadlines_met sched_edf.

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

1 subgoal (ID 2056)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  all_deadlines_met sched_edf

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

  Proof.
    move⇒ j t.

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

1 subgoal (ID 2059)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at sched_edf j t -> job_meets_deadline sched_edf j

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

    rewrite /sched_edf /job_meets_deadline.

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

1 subgoal (ID 2067)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at (edf_transform sched) j t ->
  completed_by (edf_transform sched) j (job_deadline j)

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

    set t_dl := (job_deadline j).

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

1 subgoal (ID 2071)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  ============================
  scheduled_at (edf_transform sched) j t ->
  completed_by (edf_transform sched) j t_dl

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

    rewrite (identical_prefix_completed_by _ (edf_transform_prefix sched t_dl.+1) t_dl) //;
            last by apply (identical_prefix_inclusion _ _ t_dl.+1) ⇒ //; apply edf_finite_prefix.

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

1 subgoal (ID 2095)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  ============================
  scheduled_at (edf_transform sched) j t ->
  completed_by (edf_transform_prefix sched (succn t_dl)) j t_dl

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

    move⇒ SCHED_AT; move: (SCHED_AT).

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

1 subgoal (ID 2178)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  SCHED_AT : scheduled_at (edf_transform sched) j t
  ============================
  scheduled_at (edf_transform sched) j t ->
  completed_by (edf_transform_prefix sched (succn t_dl)) j t_dl

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

    rewrite (identical_prefix_scheduled_at _ (edf_transform_prefix sched t_dl.+1) t_dl).

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

3 subgoals (ID 2200)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  SCHED_AT : scheduled_at (edf_transform sched) j t
  ============================
  scheduled_at (edf_transform_prefix sched (succn t_dl)) j t ->
  completed_by (edf_transform_prefix sched (succn t_dl)) j t_dl

subgoal 2 (ID 2201) is:
 identical_prefix (edf_transform sched)
   (edf_transform_prefix sched (succn t_dl)) t_dl
subgoal 3 (ID 2202) is:
 t < t_dl

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

    - move: (edf_prefix_well_formedness sched H_jobs_must_arrive_to_execute
                                        H_completed_jobs_dont_execute H_no_deadline_misses t_dl.+1) ⇒ [_ [_ DL]].

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

3 subgoals (ID 2229)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  SCHED_AT : scheduled_at (edf_transform sched) j t
  DL : all_deadlines_met (edf_transform_prefix sched (succn t_dl))
  ============================
  scheduled_at (edf_transform_prefix sched (succn t_dl)) j t ->
  completed_by (edf_transform_prefix sched (succn t_dl)) j t_dl

subgoal 2 (ID 2201) is:
 identical_prefix (edf_transform sched)
   (edf_transform_prefix sched (succn t_dl)) t_dl
subgoal 3 (ID 2202) is:
 t < t_dl

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

      now apply (DL j t).

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

2 subgoals (ID 2201)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  SCHED_AT : scheduled_at (edf_transform sched) j t
  ============================
  identical_prefix (edf_transform sched)
    (edf_transform_prefix sched (succn t_dl)) t_dl

subgoal 2 (ID 2202) is:
 t < t_dl

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

    - by apply (identical_prefix_inclusion _ _ t_dl.+1) ⇒ //; apply edf_finite_prefix.

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

1 subgoal (ID 2202)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  t_dl := job_deadline j : instant
  SCHED_AT : scheduled_at (edf_transform sched) j t
  ============================
  t < t_dl

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

    - by apply edf_prefix_scheduled_job_has_later_deadline with (sched0 := sched) (horizon := t.+1).

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

No more subgoals.

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

  Qed.

We observe that no new jobs are introduced: any job scheduled in the EDF schedule were also present in the reference schedule.
  Lemma edf_transform_job_scheduled:
    ∀ j t, scheduled_at sched_edf j t → ∃ t', scheduled_at sched j t'.

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

1 subgoal (ID 2069)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched_edf j t -> exists t' : instant, scheduled_at sched j t'

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

  Proof.
    move⇒ j t.

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

1 subgoal (ID 2071)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at sched_edf j t -> exists t' : instant, scheduled_at sched j t'

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

    rewrite /sched_edf /edf_transform {1}scheduled_at_def -scheduled_at_def.

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

1 subgoal (ID 2093)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  ============================
  scheduled_at (edf_transform_prefix sched (succn t)) j t ->
  exists t' : instant, scheduled_at sched j t'

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

    by apply edf_prefix_job_scheduled.

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

No more subgoals.

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

  Qed.

Conversely, we observe that no jobs are lost: any job scheduled in the reference schedule is also present in the EDF schedule.
  Lemma edf_transform_job_scheduled':
    ∀ j t, scheduled_at sched j t → ∃ t', scheduled_at sched_edf j t'.

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

1 subgoal (ID 2082)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  ============================
  forall (j : Job) (t : instant),
  scheduled_at sched j t -> exists t' : instant, scheduled_at sched_edf j t'

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

  Proof.
    move⇒ j t SCHED_j.

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

1 subgoal (ID 2085)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  ============================
  exists t' : instant, scheduled_at sched_edf j t'

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

    have EX: ∃ t', scheduled_at (edf_transform_prefix sched (job_deadline j)) j t'
      by apply edf_prefix_job_scheduled' with (t0 := t).

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

1 subgoal (ID 2102)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  EX : exists t' : instant,
         scheduled_at (edf_transform_prefix sched (job_deadline j)) j t'
  ============================
  exists t' : instant, scheduled_at sched_edf j t'

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

    move: EX ⇒ [t' SCHED'].

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

1 subgoal (ID 2115)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  t' : instant
  SCHED' : scheduled_at (edf_transform_prefix sched (job_deadline j)) j t'
  ============================
  exists t'0 : instant, scheduled_at sched_edf j t'0

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

    ∃ t'.

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

1 subgoal (ID 2117)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  t' : instant
  SCHED' : scheduled_at (edf_transform_prefix sched (job_deadline j)) j t'
  ============================
  scheduled_at sched_edf j t'

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

    rewrite /sched_edf /edf_transform scheduled_at_def.

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

1 subgoal (ID 2132)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  t' : instant
  SCHED' : scheduled_at (edf_transform_prefix sched (job_deadline j)) j t'
  ============================
  edf_transform_prefix sched (succn t') t' == Some j

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

    rewrite (edf_prefix_inclusion _ _ _ _ t'.+1 (job_deadline j)) -?scheduled_at_def⇒ //.

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

1 subgoal (ID 2171)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  j : Job
  t : instant
  SCHED_j : scheduled_at sched j t
  t' : instant
  SCHED' : scheduled_at (edf_transform_prefix sched (job_deadline j)) j t'
  ============================
  t' < job_deadline j

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

    now apply edf_prefix_scheduled_job_has_later_deadline with (sched0 := sched) (horizon := job_deadline j).

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

No more subgoals.

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

  Qed.

Next, we note that [edf_transform] maintains the property that all jobs stem from a given arrival sequence.
  Section ArrivalSequence.

For any arrival sequence,...
    Variable arr_seq: arrival_sequence Job.

...if all jobs in the original schedule come from the arrival sequence,...
    Hypothesis H_from_arr_seq: jobs_come_from_arrival_sequence sched arr_seq.

...then all jobs in the transformed EDF schedule still come from the same arrival sequence.
    Lemma edf_transform_jobs_come_from_arrival_sequence:
      jobs_come_from_arrival_sequence sched_edf arr_seq.

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

1 subgoal (ID 2089)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence sched_edf arr_seq

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

    Proof.
      rewrite /sched_edf /edf_transform.

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

1 subgoal (ID 2097)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence
    (fun t : instant => edf_transform_prefix sched (succn t) t) arr_seq

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

      move⇒ j t.

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

1 subgoal (ID 2100)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  j : Job
  t : instant
  ============================
  scheduled_at (fun t0 : instant => edf_transform_prefix sched (succn t0) t0)
    j t -> arrives_in arr_seq j

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

      rewrite scheduled_at_def - scheduled_at_def.

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

1 subgoal (ID 2114)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  sched : schedule (processor_state Job)
  H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
  H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
  H_no_deadline_misses : all_deadlines_met sched
  sched_edf := edf_transform sched : instant -> processor_state Job
  arr_seq : arrival_sequence Job
  H_from_arr_seq : jobs_come_from_arrival_sequence sched arr_seq
  j : Job
  t : instant
  ============================
  scheduled_at (edf_transform_prefix sched (succn t)) j t ->
  arrives_in arr_seq j

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

      now apply (edf_prefix_jobs_come_from_arrival_sequence sched t.+1 arr_seq H_from_arr_seq).

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

No more subgoals.

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

    Qed.

  End ArrivalSequence.

End EDFTransformFacts.

Finally, we state the theorems that jointly make up the EDF optimality claim.
Section Optimality.
For any given type of jobs...
  Context {Job : JobType} `{JobCost Job} `{JobDeadline Job} `{JobArrival Job}.

... consider an arbitrary valid job arrival sequence ...
  Variable arr_seq: arrival_sequence Job.
  Hypothesis H_arr_seq_valid: valid_arrival_sequence arr_seq.

... and an ideal uniprocessor schedule...
  Variable sched: schedule (ideal.processor_state Job).

... that corresponds to the given arrival sequence.
  Hypothesis H_sched_valid: valid_schedule sched arr_seq.

In the following, let [equivalent_edf_schedule] denote the schedule that results from the EDF transformation.
  Let equivalent_edf_schedule := edf_transform sched.

  Section AllDeadlinesMet.

Suppose no job scheduled in the given reference schedule misses a deadline.
    Hypothesis H_no_deadline_misses: all_deadlines_met sched.

Then the resulting EDF schedule is a valid schedule for the given arrival sequence...
    Theorem edf_schedule_is_valid:
      valid_schedule equivalent_edf_schedule arr_seq.

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

1 subgoal (ID 2035)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  ============================
  valid_schedule equivalent_edf_schedule arr_seq

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

    Proof.
      move: H_sched_valid ⇒ [COME READY].

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

1 subgoal (ID 2047)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  valid_schedule equivalent_edf_schedule arr_seq

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

      rewrite /valid_schedule; split;
        first by apply edf_transform_jobs_come_from_arrival_sequence.

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

1 subgoal (ID 2057)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  jobs_must_be_ready_to_execute equivalent_edf_schedule

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

      have ARR := jobs_must_arrive_to_be_ready sched READY.

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

1 subgoal (ID 2072)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  ============================
  jobs_must_be_ready_to_execute equivalent_edf_schedule

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

      have COMP := completed_jobs_are_not_ready sched READY.

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

1 subgoal (ID 2083)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  ============================
  jobs_must_be_ready_to_execute equivalent_edf_schedule

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

      apply basic_readiness_compliance.

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

2 subgoals (ID 2089)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  ============================
  jobs_must_arrive_to_execute equivalent_edf_schedule

subgoal 2 (ID 2090) is:
 completed_jobs_dont_execute equivalent_edf_schedule

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

      - by apply edf_transform_jobs_must_arrive.

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

1 subgoal (ID 2090)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  ============================
  completed_jobs_dont_execute equivalent_edf_schedule

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

      - by apply edf_transform_completed_jobs_dont_execute.

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

No more subgoals.

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

    Qed.

...and no scheduled job misses its deadline.
    Theorem edf_schedule_meets_all_deadlines:
      all_deadlines_met equivalent_edf_schedule.

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

1 subgoal (ID 2042)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  ============================
  all_deadlines_met equivalent_edf_schedule

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

    Proof.
      move: H_sched_valid ⇒ [COME READY].

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

1 subgoal (ID 2054)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  all_deadlines_met equivalent_edf_schedule

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

      have ARR := jobs_must_arrive_to_be_ready sched READY.

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

1 subgoal (ID 2065)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  ============================
  all_deadlines_met equivalent_edf_schedule

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

      have COMP := completed_jobs_are_not_ready sched READY.

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

1 subgoal (ID 2076)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses : all_deadlines_met sched
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  ============================
  all_deadlines_met equivalent_edf_schedule

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

      now apply edf_transform_deadlines_met.

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

No more subgoals.

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

    Qed.

  End AllDeadlinesMet.

Next, we strengthen the above "no deadline misses" claim by relating it not just to all scheduled jobs, but to all jobs in the given arrival sequence.
  Section AllDeadlinesOfArrivalsMet.

Suppose no job that's part of the arrival sequence misses a deadline in the given reference schedule.
    Hypothesis H_no_deadline_misses_of_arrivals: all_deadlines_of_arrivals_met arr_seq sched.

Then no job that's part of the arrival sequence misses a deadline in the EDF schedule, either.
    Theorem edf_schedule_meets_all_deadlines_wrt_arrivals:
      all_deadlines_of_arrivals_met arr_seq equivalent_edf_schedule.

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

1 subgoal (ID 2034)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  ============================
  all_deadlines_of_arrivals_met arr_seq equivalent_edf_schedule

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

    Proof.
      move⇒ j ARR_j.

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

1 subgoal (ID 2037)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

      move: H_sched_valid ⇒ [COME READY].

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

1 subgoal (ID 2049)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

      have ARR := jobs_must_arrive_to_be_ready sched READY.

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

1 subgoal (ID 2060)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

      have COMP := completed_jobs_are_not_ready sched READY.

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

1 subgoal (ID 2071)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

      destruct (job_cost j == 0) eqn:COST.

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

2 subgoals (ID 2084)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = true
  ============================
  job_meets_deadline equivalent_edf_schedule j

subgoal 2 (ID 2085) is:
 job_meets_deadline equivalent_edf_schedule j

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

      - move: COST ⇒ /eqP COST.

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

2 subgoals (ID 2149)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : job_cost j = 0
  ============================
  job_meets_deadline equivalent_edf_schedule j

subgoal 2 (ID 2085) is:
 job_meets_deadline equivalent_edf_schedule j

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

        rewrite /job_meets_deadline /completed_by COST.

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

2 subgoals (ID 2165)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : job_cost j = 0
  ============================
  0 <= service equivalent_edf_schedule j (job_deadline j)

subgoal 2 (ID 2085) is:
 job_meets_deadline equivalent_edf_schedule j

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

        now apply leq0n.

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

1 subgoal (ID 2085)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

      - move: (neq0_lt0n COST) ⇒ NONZERO.

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

1 subgoal (ID 2168)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

        move: (H_no_deadline_misses_of_arrivals j ARR_j).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2169)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  ============================
  job_meets_deadline sched j -> job_meets_deadline equivalent_edf_schedule j

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

rewrite {1}/job_meets_deadline ⇒ COMP_j.

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

1 subgoal (ID 2177)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  COMP_j : completed_by sched j (job_deadline j)
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

        move: (completed_implies_scheduled_before sched j NONZERO ARR (job_deadline j) COMP_j) ⇒ [t' [_ SCHED']].

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

1 subgoal (ID 2207)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  COMP_j : completed_by sched j (job_deadline j)
  t' : nat
  SCHED' : scheduled_at sched j t'
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

        move: (all_deadlines_met_in_valid_schedule arr_seq sched COME H_no_deadline_misses_of_arrivals) ⇒ NO_MISSES.

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

1 subgoal (ID 2215)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  COMP_j : completed_by sched j (job_deadline j)
  t' : nat
  SCHED' : scheduled_at sched j t'
  NO_MISSES : all_deadlines_met sched
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

        move: (edf_transform_job_scheduled' sched ARR COMP NO_MISSES j t' SCHED') ⇒ [t'' SCHED''].

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

1 subgoal (ID 2231)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  COMP_j : completed_by sched j (job_deadline j)
  t' : nat
  SCHED' : scheduled_at sched j t'
  NO_MISSES : all_deadlines_met sched
  t'' : instant
  SCHED'' : scheduled_at (edf_transform sched) j t''
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

        move: (edf_schedule_meets_all_deadlines NO_MISSES) ⇒ DL_MET.

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

1 subgoal (ID 2233)
  
  Job : JobType
  H : JobCost Job
  H0 : JobDeadline Job
  H1 : JobArrival Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_sched_valid : valid_schedule sched arr_seq
  equivalent_edf_schedule := edf_transform sched
   : instant -> processor_state Job
  H_no_deadline_misses_of_arrivals : all_deadlines_of_arrivals_met arr_seq
                                       sched
  j : Job
  ARR_j : arrives_in arr_seq j
  COME : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ARR : jobs_must_arrive_to_execute sched
  COMP : completed_jobs_dont_execute sched
  COST : (job_cost j == 0) = false
  NONZERO : 0 < job_cost j
  COMP_j : completed_by sched j (job_deadline j)
  t' : nat
  SCHED' : scheduled_at sched j t'
  NO_MISSES : all_deadlines_met sched
  t'' : instant
  SCHED'' : scheduled_at (edf_transform sched) j t''
  DL_MET : all_deadlines_met equivalent_edf_schedule
  ============================
  job_meets_deadline equivalent_edf_schedule j

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

        now apply: (DL_MET j t'' SCHED'').

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

No more subgoals.

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

    Qed.

  End AllDeadlinesOfArrivalsMet.

End Optimality.