Library prosa.analysis.facts.transform.wc_correctness


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

Welcome to Coq 8.11.2 (June 2020)

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


Require Export prosa.model.schedule.work_conserving.
Require Export prosa.analysis.facts.model.ideal_schedule.
Require Export prosa.analysis.transform.wc_trans.
Require Export prosa.analysis.facts.transform.swaps.
Require Export prosa.analysis.definitions.schedulability.
Require Export prosa.util.list.

From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.

Correctness of the work-conservation transformation

This file contains the main argument of the work-conservation proof, starting with an analysis of the individual functions that drive the work-conservation transformation of a given reference schedule and ending with the proofs of individual properties of the obtained work-conserving schedule.
Throughout this file, we assume ideal uniprocessor schedules and the basic (i.e., Liu & Layland) readiness model under which any pending job is ready.
In order to discuss the correctness of the work-conservation transformation at a high level, we first need a set of lemmas about the inner parts of the procedure.
Consider any type of jobs with arrival times, costs, and deadlines...
  Context {Job : JobType}.
  Context `{JobArrival Job}.
  Context `{JobCost Job}.
  Context `{JobDeadline Job}.

...and an arbitrary arrival sequence.
We introduce the notion of work-conservation at a given time [t]. The definition is based on the concept of readiness of a job, and states that the presence of a ready job implies that the processor is not idle.
  Definition is_work_conserving_at sched t :=
    ( j, arrives_in arr_seq j job_ready sched j t)
     j, sched t = Some j.

First, we prove some useful properties about the most fundamental operation of the work-conservation transformation: swapping two processor states [t1] and [fsc], with [fsc] being a valid swap candidate of [t1].
Consider an ideal uniprocessor schedule...
    Variable sched: schedule (ideal.processor_state Job).

...in which jobs must be ready to execute.
Consider an arbitrary time instant [t1].
    Variable t1: instant.

Let us define [fsc] as the result of the search for a swap candidate starting from [t1]...
...and [sched'] as the schedule resulting from the swap.
    Let sched' := swapped sched t1 fsc.

First, we show that, in any case, the result of the search will yield an instant that is in the future (or, in case of failure, equal to [t1]).
    Lemma swap_candidate_is_in_future:
      t1 fsc.

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

1 subgoal (ID 2115)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  ============================
  t1 <= fsc

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


    Proof.
      rewrite /fsc /find_swap_candidate.

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

1 subgoal (ID 2123)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  ============================
  t1 <=
  match
    search_arg sched (relevant_pstate t1) (fun=> xpred0) t1
      (max_deadline_for_jobs_arrived_before arr_seq t1)
  with
  | Some t_swap => t_swap
  | None => t1
  end

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


      destruct search_arg as [n|] eqn:search_result; last by done.

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

1 subgoal (ID 2142)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  n : nat
  search_result : search_arg sched (relevant_pstate t1) 
                    (fun=> xpred0) t1
                    (max_deadline_for_jobs_arrived_before arr_seq t1) =
                  Some n
  ============================
  t1 <= n

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


      apply search_arg_in_range in search_result.

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

1 subgoal (ID 2145)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  n : nat
  search_result : t1 <= n < max_deadline_for_jobs_arrived_before arr_seq t1
  ============================
  t1 <= n

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


        by move:search_result ⇒ /andP [LEQ LMAX].

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

No more subgoals.

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


    Qed.

Also, we show that the search will not yield jobs that arrive later than the given reference time.
    Lemma fsc_respects_has_arrived:
       j t,
        sched (find_swap_candidate arr_seq sched t) == Some j
        has_arrived j t.

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

1 subgoal (ID 2129)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  ============================
  forall (j : Job) (t : instant),
  sched (find_swap_candidate arr_seq sched t) == Some j -> has_arrived j t

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


    Proof.
      movej t.

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

1 subgoal (ID 2131)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  ============================
  sched (find_swap_candidate arr_seq sched t) == Some j -> has_arrived j t

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


      rewrite /find_swap_candidate.

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

1 subgoal (ID 2138)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  ============================
  sched
    match
      search_arg sched (relevant_pstate t) (fun=> xpred0) t
        (max_deadline_for_jobs_arrived_before arr_seq t)
    with
    | Some t_swap => t_swap
    | None => t
    end == Some j -> has_arrived j t

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


      destruct search_arg eqn:RES; last first.

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

2 subgoals (ID 2158)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = None
  ============================
  sched t == Some j -> has_arrived j t

subgoal 2 (ID 2157) is:
 sched n == Some j -> has_arrived j t

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


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

1 subgoal (ID 2158)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = None
  ============================
  sched t == Some j -> has_arrived j t

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


move: (H_jobs_must_be_ready j t).

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

1 subgoal (ID 2159)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = None
  ============================
  (scheduled_at sched j t -> job_ready sched j t) ->
  sched t == Some j -> has_arrived j t

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


        rewrite /scheduled_at scheduled_in_defREADY SCHED_J.

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

1 subgoal (ID 2174)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = None
  READY : sched t == Some j -> job_ready sched j t
  SCHED_J : sched t == Some j
  ============================
  has_arrived j t

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


        apply READY in SCHED_J.

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

1 subgoal (ID 2175)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = None
  READY : sched t == Some j -> job_ready sched j t
  SCHED_J : job_ready sched j t
  ============================
  has_arrived j t

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


        by apply (ready_implies_arrived sched).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2157)

subgoal 1 (ID 2157) is:
 sched n == Some j -> has_arrived j t

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


}

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

1 subgoal (ID 2157)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  n : nat
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = 
        Some n
  ============================
  sched n == Some j -> has_arrived j t

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


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

1 subgoal (ID 2157)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  n : nat
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = 
        Some n
  ============================
  sched n == Some j -> has_arrived j t

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


move⇒ /eqP SCHED_J.

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

1 subgoal (ID 2217)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  n : nat
  RES : search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t) = 
        Some n
  SCHED_J : sched n = Some j
  ============================
  has_arrived j t

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


        move: RES ⇒ /search_arg_pred.

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

1 subgoal (ID 2412)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  n : nat
  SCHED_J : sched n = Some j
  ============================
  relevant_pstate t (sched n) -> has_arrived j t

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


        rewrite SCHED_J //.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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


}

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

No more subgoals.

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


    Qed.

Next, we extend the previous lemma by stating that no job in the transformed schedule is scheduled before its arrival.
    Lemma swap_jobs_must_arrive_to_execute:
        jobs_must_arrive_to_execute sched'.

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

1 subgoal (ID 2134)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  ============================
  jobs_must_arrive_to_execute sched'

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


    Proof.
      movej t SCHED_AT.

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

1 subgoal (ID 2138)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  ============================
  has_arrived j t

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


      move: (swap_job_scheduled_cases _ _ _ _ _ SCHED_AT)=> [OTHER |[AT_T1 | AT_T2]].

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

3 subgoals (ID 2165)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  OTHER : scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j t
  ============================
  has_arrived j t

subgoal 2 (ID 2178) is:
 has_arrived j t
subgoal 3 (ID 2179) is:
 has_arrived j t

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


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

1 subgoal (ID 2165)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  OTHER : scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j t
  ============================
  has_arrived j t

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


have READY: job_ready sched j t by apply H_jobs_must_be_ready; rewrite -OTHER //.

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

1 subgoal (ID 2191)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  OTHER : scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j t
  READY : job_ready sched j t
  ============================
  has_arrived j t

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


          by apply (ready_implies_arrived sched).
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2178)

subgoal 1 (ID 2178) is:
 has_arrived j t
subgoal 2 (ID 2179) is:
 has_arrived j t

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


}

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

2 subgoals (ID 2178)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  AT_T1 : t = t1 /\
          scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j fsc
  ============================
  has_arrived j t

subgoal 2 (ID 2179) is:
 has_arrived j t

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


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

1 subgoal (ID 2178)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  AT_T1 : t = t1 /\
          scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j fsc
  ============================
  has_arrived j t

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


set t2 := find_swap_candidate arr_seq sched t1 in AT_T1.

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

1 subgoal (ID 2226)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  AT_T1 : t = t1 /\
          scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j fsc
  ============================
  has_arrived j t

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


        move: AT_T1 ⇒ [EQ_T1 SCHED_AT'].

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

1 subgoal (ID 2239)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T1 : t = t1
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j fsc
  ============================
  has_arrived j t

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


        apply fsc_respects_has_arrived.

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

1 subgoal (ID 2240)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T1 : t = t1
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j fsc
  ============================
  sched (find_swap_candidate arr_seq sched t) == Some j

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


        move: SCHED_AT.

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

1 subgoal (ID 2242)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T1 : t = t1
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j fsc
  ============================
  scheduled_at sched' j t ->
  sched (find_swap_candidate arr_seq sched t) == Some j

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


        rewrite EQ_T1 /SCHED_AT' /sched' -/t2.

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

1 subgoal (ID 2247)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T1 : t = t1
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j fsc
  ============================
  scheduled_at (swapped sched t1 fsc) j t1 -> sched t2 == Some j

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


        rewrite EQ_T1 in SCHED_AT'.

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

1 subgoal (ID 2272)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T1 : t = t1
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t1 =
              scheduled_at sched j fsc
  ============================
  scheduled_at (swapped sched t1 fsc) j t1 -> sched t2 == Some j

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


        rewrite SCHED_AT' /scheduled_at.

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

1 subgoal (ID 2281)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T1 : t = t1
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t1 =
              scheduled_at sched j fsc
  ============================
  scheduled_in j (sched fsc) -> sched t2 == Some j

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


        by rewrite scheduled_in_def.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2179)

subgoal 1 (ID 2179) is:
 has_arrived j t

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


}

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

1 subgoal (ID 2179)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  AT_T2 : t = fsc /\
          scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j t1
  ============================
  has_arrived j t

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


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

1 subgoal (ID 2179)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  AT_T2 : t = fsc /\
          scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j t1
  ============================
  has_arrived j t

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


set t2 := find_swap_candidate arr_seq sched t1 in AT_T2.

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

1 subgoal (ID 2316)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  AT_T2 : t = fsc /\
          scheduled_at (swapped sched t1 fsc) j t = scheduled_at sched j t1
  ============================
  has_arrived j t

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


        move: AT_T2 ⇒ [EQ_T2 SCHED_AT'].

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

1 subgoal (ID 2329)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ============================
  has_arrived j t

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


        have ORDER: t1t2 by apply swap_candidate_is_in_future.

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

1 subgoal (ID 2332)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ORDER : t1 <= t2
  ============================
  has_arrived j t

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


        have READY: job_ready sched j t1 by apply H_jobs_must_be_ready; rewrite -SCHED_AT' //.

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

1 subgoal (ID 2344)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ORDER : t1 <= t2
  READY : job_ready sched j t1
  ============================
  has_arrived j t

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


        rewrite /job_ready /basic_ready_instance /pending /completed_by in READY.

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

1 subgoal (ID 2408)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ORDER : t1 <= t2
  READY : has_arrived j t1 && ~~ (job_cost j <= service sched j t1)
  ============================
  has_arrived j t

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


        move: READY ⇒ /andP [ARR _].

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

1 subgoal (ID 2450)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ORDER : t1 <= t2
  ARR : has_arrived j t1
  ============================
  has_arrived j t

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


        rewrite EQ_T2.

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

1 subgoal (ID 2452)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ORDER : t1 <= t2
  ARR : has_arrived j t1
  ============================
  has_arrived j fsc

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


        rewrite /has_arrived in ARR.

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

1 subgoal (ID 2483)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  EQ_T2 : t = fsc
  SCHED_AT' : scheduled_at (swapped sched t1 fsc) j t =
              scheduled_at sched j t1
  ORDER : t1 <= t2
  ARR : job_arrival j <= t1
  ============================
  has_arrived j fsc

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


        apply leq_trans with (n := t1) ⇒ //.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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


}

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

No more subgoals.

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


    Qed.

Finally we show that, in the transformed schedule, jobs are scheduled only if they are ready.
    Lemma fsc_jobs_must_be_ready_to_execute:
      jobs_must_be_ready_to_execute sched'.

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

1 subgoal (ID 2141)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  ============================
  jobs_must_be_ready_to_execute sched'

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


    Proof.
      movej t SCHED_AT.

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

1 subgoal (ID 2145)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  ============================
  job_ready sched' j t

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


      rewrite /sched'.

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

1 subgoal (ID 2146)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  ============================
  job_ready (swapped sched t1 fsc) j t

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


      set t2 := find_swap_candidate arr_seq sched t1.

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

1 subgoal (ID 2151)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  job_ready (swapped sched t1 fsc) j t

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


      rewrite /job_ready /basic_ready_instance /pending.

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

1 subgoal (ID 2182)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  has_arrived j t && ~~ completed_by (swapped sched t1 fsc) j t

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


      apply /andP; split; first by apply swap_jobs_must_arrive_to_execute.

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

1 subgoal (ID 2209)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  ~~ completed_by (swapped sched t1 fsc) j t

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


      rewrite /completed_by; rewrite -ltnNge.

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

1 subgoal (ID 2221)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  service (swapped sched t1 fsc) j t < job_cost j

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


      apply swapped_completed_jobs_dont_execute ⇒ //.

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

4 subgoals (ID 2226)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  t1 <= fsc

subgoal 2 (ID 2227) is:
 unit_service_proc_model (option_eqType Job)
subgoal 3 (ID 2228) is:
 ideal_progress_proc_model (option_eqType Job)
subgoal 4 (ID 2229) is:
 completed_jobs_dont_execute sched

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


      - by apply swap_candidate_is_in_future.

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

3 subgoals (ID 2227)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  unit_service_proc_model (option_eqType Job)

subgoal 2 (ID 2228) is:
 ideal_progress_proc_model (option_eqType Job)
subgoal 3 (ID 2229) is:
 completed_jobs_dont_execute sched

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


      - by apply ideal_proc_model_provides_unit_service.

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

2 subgoals (ID 2228)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  ideal_progress_proc_model (option_eqType Job)

subgoal 2 (ID 2229) is:
 completed_jobs_dont_execute sched

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


      - by apply ideal_proc_model_ensures_ideal_progress.

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

1 subgoal (ID 2229)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_jobs_must_be_ready : jobs_must_be_ready_to_execute sched
  t1 : instant
  fsc := find_swap_candidate arr_seq sched t1 : nat
  sched' := swapped sched t1 fsc : schedule (processor_state Job)
  j : Job
  t : instant
  SCHED_AT : scheduled_at sched' j t
  t2 := find_swap_candidate arr_seq sched t1 : nat
  ============================
  completed_jobs_dont_execute sched

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


      - by eapply completed_jobs_are_not_ready.

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

No more subgoals.

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


    Qed.

  End JobsMustBeReadyFindSwapCandidate.

In the following section, we put our attention on the point-wise transformation performed at each point in time prior to the horizon.
  Section MakeWCAtFacts.

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

...and take an arbitrary point in time...
    Variable t: instant.

...we define [sched'] as the resulting schedule after one point-wise transformation.
    Let sched' := make_wc_at arr_seq sched t.

We start by proving that the point-wise transformation can only lead to higher service for a job at a given time. This is true because we swap only idle processor states with ones in which a job is scheduled.
    Lemma mwa_service_bound:
       j t, service sched j t service sched' j t.

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

1 subgoal (ID 2118)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  forall (j : Job) (t0 : instant), service sched j t0 <= service sched' j t0

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


    Proof.
      intros j t'.

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

1 subgoal (ID 2120)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ============================
  service sched j t' <= service sched' j t'

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


      rewrite /sched' /make_wc_at.

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

1 subgoal (ID 2128)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ============================
  service sched j t' <=
  service
    match sched t with
    | Some _ => sched
    | None => swapped sched t (find_swap_candidate arr_seq sched t)
    end j t'

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


      destruct (sched t) eqn:PSTATE ⇒ //.

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

1 subgoal (ID 2142)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  ============================
  service sched j t' <=
  service (swapped sched t (find_swap_candidate arr_seq sched t)) j t'

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


      set t2:= (find_swap_candidate arr_seq sched t).

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

1 subgoal (ID 2169)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      move: (swap_candidate_is_in_future sched t) ⇒ ORDER.

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

1 subgoal (ID 2171)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      destruct (leqP t' t) as [BOUND1|BOUND1];
        first by rewrite (service_before_swap_invariant _ t t2) ⇒ //.

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

1 subgoal (ID 2195)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      destruct (ltnP t2 t') as [BOUND2 | BOUND2];
        first by rewrite (service_after_swap_invariant _ t t2) ⇒ //.

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

1 subgoal (ID 2237)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      destruct (scheduled_at sched j t) eqn:SCHED_AT_T1;
        first by move:SCHED_AT_T1; rewrite scheduled_at_def PSTATE ⇒ /eqP.

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

1 subgoal (ID 2269)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  SCHED_AT_T1 : scheduled_at sched j t = false
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      move: SCHED_AT_T1 ⇒ /negbT NOT_AT_t1.

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

1 subgoal (ID 2430)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  NOT_AT_t1 : ~~ scheduled_at sched j t
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      destruct (scheduled_at sched j t2) eqn:SCHED_AT_T2;
        last by move: SCHED_AT_T2 ⇒ /negbT NOT_AT_t2; rewrite (service_of_others_invariant _ t t2).

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

1 subgoal (ID 2443)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  NOT_AT_t1 : ~~ scheduled_at sched j t
  SCHED_AT_T2 : scheduled_at sched j t2 = true
  ============================
  service sched j t' <= service (swapped sched t t2) j t'

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


      rewrite /swapped /service -service_at_other_times_invariant; last by left.

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

1 subgoal (ID 2582)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  NOT_AT_t1 : ~~ scheduled_at sched j t
  SCHED_AT_T2 : scheduled_at sched j t2 = true
  ============================
  service_during sched j 0 t' <=
  service_during (replace_at sched t (sched t2)) j 0 t'

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


      rewrite service_in_replaced; last by apply /andP; split ⇒ //.

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

1 subgoal (ID 2600)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  NOT_AT_t1 : ~~ scheduled_at sched j t
  SCHED_AT_T2 : scheduled_at sched j t2 = true
  ============================
  service_during sched j 0 t' <=
  service_during sched j 0 t' +
  service_at (replace_at sched t (sched t2)) j t - 
  service_at sched j t

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


      rewrite (not_scheduled_implies_no_service _ _ _ NOT_AT_t1) subn0.

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

1 subgoal (ID 2653)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  PSTATE : sched t = None
  t2 := find_swap_candidate arr_seq sched t : nat
  ORDER : t <= find_swap_candidate arr_seq sched t
  BOUND1 : t < t'
  BOUND2 : t' <= t2
  NOT_AT_t1 : ~~ scheduled_at sched j t
  SCHED_AT_T2 : scheduled_at sched j t2 = true
  ============================
  service_during sched j 0 t' <=
  service_during sched j 0 t' +
  service_at (replace_at sched t (sched t2)) j t

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


        by apply leq_addr.

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

No more subgoals.

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


    Qed.

Next, we show that any ready job in the transformed schedule must be ready also in the original one, since the transformation can only lead to higher service.
    Lemma mwa_ready_job_also_ready_in_original_schedule:
       j t, job_ready sched' j t job_ready sched j t.

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

1 subgoal (ID 2135)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  forall (j : Job) (t0 : instant),
  job_ready sched' j t0 -> job_ready sched j t0

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


    Proof.
      intros j t'.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2137)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ============================
  job_ready sched' j t' -> job_ready sched j t'

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


      rewrite /job_ready /basic_ready_instance /pending.

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

1 subgoal (ID 2168)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ============================
  has_arrived j t' && ~~ completed_by sched' j t' ->
  has_arrived j t' && ~~ completed_by sched j t'

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


      move⇒ /andP [ARR COMP_BY].

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

1 subgoal (ID 2208)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ARR : has_arrived j t'
  COMP_BY : ~~ completed_by sched' j t'
  ============================
  has_arrived j t' && ~~ completed_by sched j t'

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


      rewrite ARR Bool.andb_true_l //.

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

1 subgoal (ID 2213)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ARR : has_arrived j t'
  COMP_BY : ~~ completed_by sched' j t'
  ============================
  ~~ completed_by sched j t'

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


      move: COMP_BY; apply contra.

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

1 subgoal (ID 2238)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ARR : has_arrived j t'
  ============================
  completed_by sched j t' -> completed_by sched' j t'

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


      rewrite /completed_by.

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

1 subgoal (ID 2245)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ARR : has_arrived j t'
  ============================
  job_cost j <= service sched j t' -> job_cost j <= service sched' j t'

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


      have LEQ: (service sched j t') (service sched' j t') by apply mwa_service_bound.

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

1 subgoal (ID 2254)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ARR : has_arrived j t'
  LEQ : service sched j t' <= service sched' j t'
  ============================
  job_cost j <= service sched j t' -> job_cost j <= service sched' j t'

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


      moveLEQ'; move:LEQ; move: LEQ'.

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

1 subgoal (ID 2259)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : instant
  ARR : has_arrived j t'
  ============================
  job_cost j <= service sched j t' ->
  service sched j t' <= service sched' j t' ->
  job_cost j <= service sched' j t'

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


        by apply leq_trans.

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

No more subgoals.

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


    Qed.

Since the search for a swap candidate is performed until the latest deadline among all the jobs arrived before the reference time, we need to show that the computed deadline is indeed the latest.
    Lemma max_dl_is_greatest_dl:
       j t,
        arrives_in arr_seq j
        job_arrival j t
        job_deadline j max_deadline_for_jobs_arrived_before arr_seq t.

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

1 subgoal (ID 2145)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  forall (j : Job) (t0 : nat),
  arrives_in arr_seq j ->
  job_arrival j <= t0 ->
  job_deadline j <= max_deadline_for_jobs_arrived_before arr_seq t0

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


    Proof.
      movej t' ARR_IN ARR.

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

1 subgoal (ID 2149)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : nat
  ARR_IN : arrives_in arr_seq j
  ARR : job_arrival j <= t'
  ============================
  job_deadline j <= max_deadline_for_jobs_arrived_before arr_seq t'

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


      rewrite /max_deadline_for_jobs_arrived_before.

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

1 subgoal (ID 2154)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : nat
  ARR_IN : arrives_in arr_seq j
  ARR : job_arrival j <= t'
  ============================
  job_deadline j <=
  max0 [seq job_deadline i | i <- arrivals_up_to arr_seq t']

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


      apply in_max0_le; apply map_f.

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

1 subgoal (ID 2156)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : nat
  ARR_IN : arrives_in arr_seq j
  ARR : job_arrival j <= t'
  ============================
  j \in arrivals_up_to arr_seq t'

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


      rewrite /arrivals_up_to.

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

1 subgoal (ID 2159)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  t' : nat
  ARR_IN : arrives_in arr_seq j
  ARR : job_arrival j <= t'
  ============================
  j \in arrivals_between arr_seq 0 (succn t')

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


      apply arrived_between_implies_in_arrivals;
        by move:H_arr_seq_valid ⇒ [CONS UNIQ].

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

No more subgoals.

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


    Qed.

Next, we want to show that, if a job arriving from the arrival sequence is ready at some instant, then the point-wise transformation is guaranteed to find a job to swap with. We will proceed by doing a case analysis, and show that it is impossible that a swap candidate is not found.
    Section MakeWCAtFindsReadyJobs.

We need to assume that, in the original schedule, all the deadlines of the jobs coming from the arrival sequence are met, in order to be sure that a ready job will be eventually scheduled.
We define [max_dl] as the maximum deadline for all jobs arrived before [t].
Next, we define [search_result] as the result of the search for a swap candidate. In order to take the first result, it is sufficient to define the ordering function as a constant false.
      Definition order (_ _ : nat) := false.
      Definition search_result := search_arg sched (relevant_pstate t) order t max_dl.

First, we consider the case in which the procedure finds a job to swap with.
Assuming that the processor is idle at time t...
        Hypothesis H_sched_t_idle: is_idle sched t.

...let [t_swap] be a time instant found by the search procedure.
        Variable t_swap: instant.
        Hypothesis search_result_found: search_result = Some t_swap.

We show that, since the search only yields relevant processor states, a job is found.
        Lemma make_wc_at_case_result_found:
           j: Job,
            swapped sched t t_swap t = Some j.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2166)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  search_result_found : search_result = Some t_swap
  ============================
  exists j : Job, swapped sched t t_swap t = Some j

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


        Proof.
          apply search_arg_pred in search_result_found.

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

1 subgoal (ID 2168)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  search_result_found : relevant_pstate t (sched t_swap)
  ============================
  exists j : Job, swapped sched t t_swap t = Some j

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


          move:search_result_found; rewrite /relevant_pstate.

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

1 subgoal (ID 2175)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  search_result_found : relevant_pstate t (sched t_swap)
  ============================
  match sched t_swap with
  | Some j => job_arrival j <= t
  | None => false
  end -> exists j : Job, swapped sched t t_swap t = Some j

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


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

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

1 subgoal (ID 2191)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  j_swap : Job
  SCHED : sched t_swap = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ============================
  job_arrival j_swap <= t ->
  exists j : Job, swapped sched t t_swap t = Some j

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


          moveARR.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2223)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  j_swap : Job
  SCHED : sched t_swap = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  ============================
  exists j : Job, swapped sched t t_swap t = Some j

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


rewrite /swapped /replace_at.

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

1 subgoal (ID 2229)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  j_swap : Job
  SCHED : sched t_swap = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  ============================
  exists j : Job,
    (if t_swap == t
     then sched t
     else if t == t then sched t_swap else sched t) = 
    Some j

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


          destruct (t_swap == t) eqn:SAME_SWAP.

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

2 subgoals (ID 2242)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  j_swap : Job
  SCHED : sched t_swap = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  SAME_SWAP : (t_swap == t) = true
  ============================
  exists j : Job, sched t = Some j

subgoal 2 (ID 2243) is:
 exists j : Job, (if t == t then sched t_swap else sched t) = Some j

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


          + move:SAME_SWAP ⇒ /eqP SAME_SWAP; subst t_swap.

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

2 subgoals (ID 2285)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  j_swap : Job
  SCHED : sched t = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  ============================
  exists j : Job, sched t = Some j

subgoal 2 (ID 2243) is:
 exists j : Job, (if t == t then sched t_swap else sched t) = Some j

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


            move:H_sched_t_idle ⇒ /eqP SCHED_NONE.

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

2 subgoals (ID 2320)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  j_swap : Job
  SCHED : sched t = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  SCHED_NONE : sched t = None
  ============================
  exists j : Job, sched t = Some j

subgoal 2 (ID 2243) is:
 exists j : Job, (if t == t then sched t_swap else sched t) = Some j

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


              by rewrite SCHED_NONE in SCHED; discriminate.

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

1 subgoal (ID 2243)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  j_swap : Job
  SCHED : sched t_swap = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  SAME_SWAP : (t_swap == t) = false
  ============================
  exists j : Job, (if t == t then sched t_swap else sched t) = Some j

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


          + j_swap.

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

1 subgoal (ID 2351)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_sched_t_idle : is_idle sched t
  t_swap : instant
  j_swap : Job
  SCHED : sched t_swap = Some j_swap
  search_result_found : relevant_pstate t (Some j_swap)
  ARR : job_arrival j_swap <= t
  SAME_SWAP : (t_swap == t) = false
  ============================
  (if t == t then sched t_swap else sched t) = Some j_swap

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


              by rewrite eq_refl; apply SCHED.

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

No more subgoals.

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


        Qed.

      End MakeWCAtFindsReadyJobs_CaseResultFound.

Conversely, we prove that assuming that the search yields no result brings to a contradiction.
Consider a job that arrives in the arrival sequence, and assume that it is ready at time [t] in the transformed schedule.
        Variable j: Job.
        Hypothesis H_arrives_in: arrives_in arr_seq j.
        Hypothesis H_job_ready_sched': job_ready sched' j t.

Moreover, assume the search for a swap candidate yields nothing.
        Hypothesis H_search_result_none: search_result = None.

First, note that, since nothing was found, it means there is no relevant processor state between [t] and [max_dl].
        Lemma no_relevant_state_in_range:
           t',
            t t' < max_dl
            ~~ (relevant_pstate t) (sched t').

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

1 subgoal (ID 2170)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  forall t' : nat, t <= t' < max_dl -> ~~ relevant_pstate t (sched t')

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


        Proof.
            by apply (search_arg_none _ _ (fun _ _false)).

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

No more subgoals.

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


        Qed.

Since [j] is ready at time [t], then it must be incomplete.
        Lemma service_of_j_is_less_than_cost: service sched j t < job_cost j.

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

1 subgoal (ID 2176)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  service sched j t < job_cost j

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


        Proof.
          have READY_ORIG: job_ready sched j t
            by apply (mwa_ready_job_also_ready_in_original_schedule _ _); apply H_job_ready_sched'.

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

1 subgoal (ID 2190)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  READY_ORIG : job_ready sched j t
  ============================
  service sched j t < job_cost j

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


          rewrite /job_ready /basic_ready_instance /pending.

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

1 subgoal (ID 2221)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  READY_ORIG : job_ready sched j t
  ============================
  service sched j t < job_cost j

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


          move:READY_ORIG ⇒ /andP [ARR_ NOT_COMPL_ORIG].

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

1 subgoal (ID 2263)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR_ : has_arrived j t
  NOT_COMPL_ORIG : ~~ completed_by sched j t
  ============================
  service sched j t < job_cost j

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


          rewrite /completed_by in NOT_COMPL_ORIG.

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

1 subgoal (ID 2294)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR_ : has_arrived j t
  NOT_COMPL_ORIG : ~~ (job_cost j <= service sched j t)
  ============================
  service sched j t < job_cost j

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


            by rewrite leqNgt; apply NOT_COMPL_ORIG.

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

No more subgoals.

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


        Qed.

And since [j] is incomplete and meets its deadline, the deadline of [j] is in the future.
        Lemma t_is_less_than_deadline_of_j: t job_deadline j.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2179)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  t <= job_deadline j

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


        Proof.
          move: (H_all_deadlines_of_arrivals_met j H_arrives_in)=> MEETS_DL_j.

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

1 subgoal (ID 2181)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  MEETS_DL_j : job_meets_deadline sched j
  ============================
  t <= job_deadline j

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


          move_neq_up LEQ_t1.

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

1 subgoal (ID 2209)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  MEETS_DL_j : job_meets_deadline sched j
  LEQ_t1 : job_deadline j < t
  ============================
  False

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


          unfold job_meets_deadline, completed_by in MEETS_DL_j; move_neq_down MEETS_DL_j.

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

1 subgoal (ID 2253)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  LEQ_t1 : job_deadline j < t
  ============================
  service sched j (job_deadline j) < job_cost j

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


          eapply leq_ltn_trans; last apply service_of_j_is_less_than_cost.

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

1 subgoal (ID 2255)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  LEQ_t1 : job_deadline j < t
  ============================
  service sched j (job_deadline j) <= service sched j t

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


            by apply service_monotonic, ltnW.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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


        Qed.

On the other hand, since we know that there is no relevant state between [t] and [max_dl], then it must be the case that [j] is never scheduled in this period, and hence gets no service.
        Lemma equal_service_t_max_dl: service sched j t = service sched j max_dl.

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

1 subgoal (ID 2188)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  service sched j t = service sched j max_dl

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


        Proof.
          move:(H_job_ready_sched') ⇒ /andP [ARR NOT_COMPL_sched'].

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

1 subgoal (ID 2229)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  service sched j t = service sched j max_dl

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


          rewrite -(service_cat sched j t max_dl);
            last by apply (leq_trans t_is_less_than_deadline_of_j), max_dl_is_greatest_dl.

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

1 subgoal (ID 2238)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  service sched j t = service sched j t + service_during sched j t max_dl

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


          have ZERO_SERVICE: service_during sched j t max_dl = 0.

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

2 subgoals (ID 2251)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  service_during sched j t max_dl = 0

subgoal 2 (ID 2253) is:
 service sched j t = service sched j t + service_during sched j t max_dl

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


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

1 subgoal (ID 2251)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  service_during sched j t max_dl = 0

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


apply not_scheduled_during_implies_zero_service.

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

2 subgoals (ID 2257)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  ideal_progress_proc_model (processor_state Job)

subgoal 2 (ID 2258) is:
 forall t0 : nat, t <= t0 < max_dl -> ~~ scheduled_at sched j t0

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


            apply ideal_proc_model_ensures_ideal_progress.

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

1 subgoal (ID 2258)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  forall t0 : nat, t <= t0 < max_dl -> ~~ scheduled_at sched j t0

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


            movet_at RANGE.

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

1 subgoal (ID 2261)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  t_at : nat
  RANGE : t <= t_at < max_dl
  ============================
  ~~ scheduled_at sched j t_at

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


            move:(no_relevant_state_in_range t_at RANGE) ⇒ NOT_REL.

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

1 subgoal (ID 2263)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  t_at : nat
  RANGE : t <= t_at < max_dl
  NOT_REL : ~~ relevant_pstate t (sched t_at)
  ============================
  ~~ scheduled_at sched j t_at

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


            rewrite scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2270)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  t_at : nat
  RANGE : t <= t_at < max_dl
  NOT_REL : ~~ relevant_pstate t (sched t_at)
  ============================
  sched t_at != Some j

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


            apply/negP; move ⇒ /eqP EQ.

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

1 subgoal (ID 2325)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  t_at : nat
  RANGE : t <= t_at < max_dl
  NOT_REL : ~~ relevant_pstate t (sched t_at)
  EQ : sched t_at = Some j
  ============================
  False

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


              by move: NOT_REL ⇒ /negP T; apply: T; rewrite EQ.

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

1 subgoal (ID 2253)

subgoal 1 (ID 2253) is:
 service sched j t = service sched j t + service_during sched j t max_dl

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


          }

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

1 subgoal (ID 2253)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ZERO_SERVICE : service_during sched j t max_dl = 0
  ============================
  service sched j t = service sched j t + service_during sched j t max_dl

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


            by rewrite ZERO_SERVICE; rewrite addn0.

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

No more subgoals.

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


        Qed.

Combining the previous lemmas, we can deduce that [j] misses its deadline.
        Lemma j_misses_deadline: service sched j (job_deadline j) < job_cost j.

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

1 subgoal (ID 2196)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  service sched j (job_deadline j) < job_cost j

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


        Proof.
          move:(H_job_ready_sched') ⇒ /andP [ARR NOT_COMPL_sched'].

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

1 subgoal (ID 2237)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  ============================
  service sched j (job_deadline j) < job_cost j

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


          have J_LESS := service_of_j_is_less_than_cost.

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

1 subgoal (ID 2242)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  J_LESS : service sched j t < job_cost j
  ============================
  service sched j (job_deadline j) < job_cost j

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


          rewrite equal_service_t_max_dl in J_LESS.

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

1 subgoal (ID 2269)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  J_LESS : service sched j max_dl < job_cost j
  ============================
  service sched j (job_deadline j) < job_cost j

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


          specialize (H_all_deadlines_of_arrivals_met j H_arrives_in).

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

1 subgoal (ID 2271)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  H_all_deadlines_of_arrivals_met : job_meets_deadline sched j
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  J_LESS : service sched j max_dl < job_cost j
  ============================
  service sched j (job_deadline j) < job_cost j

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


          unfold job_meets_deadline, completed_by in H_all_deadlines_of_arrivals_met.

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

1 subgoal (ID 2272)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  H_all_deadlines_of_arrivals_met : job_cost j <=
                                    service sched j (job_deadline j)
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  J_LESS : service sched j max_dl < job_cost j
  ============================
  service sched j (job_deadline j) < job_cost j

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


          eapply leq_ltn_trans.

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

2 focused subgoals
(shelved: 1) (ID 2274)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  H_all_deadlines_of_arrivals_met : job_cost j <=
                                    service sched j (job_deadline j)
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  J_LESS : service sched j max_dl < job_cost j
  ============================
  service sched j (job_deadline j) <= ?n

subgoal 2 (ID 2275) is:
 ?n < job_cost j

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


          - by apply service_monotonic, (max_dl_is_greatest_dl _ _ H_arrives_in ARR).

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

1 subgoal (ID 2275)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  H_all_deadlines_of_arrivals_met : job_cost j <=
                                    service sched j (job_deadline j)
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ARR : has_arrived j t
  NOT_COMPL_sched' : ~~ completed_by sched' j t
  J_LESS : service sched j max_dl < job_cost j
  ============================
  service sched j (max_deadline_for_jobs_arrived_before arr_seq t) <
  job_cost j

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


          - by apply J_LESS.

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

No more subgoals.

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


        Qed.

The fact that [j] misses its deadline contradicts the fact that all deadlines of jobs coming from the arrival sequence are met. We have a contradiction.
        Lemma make_wc_at_case_result_none: False.

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

1 subgoal (ID 2197)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  False

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


        Proof.
          move: (H_all_deadlines_of_arrivals_met j H_arrives_in) ⇒ NEQ.

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

1 subgoal (ID 2199)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  NEQ : job_meets_deadline sched j
  ============================
  False

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


          unfold job_meets_deadline, completed_by in NEQ.

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

1 subgoal (ID 2200)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  NEQ : job_cost j <= service sched j (job_deadline j)
  ============================
  False

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


          move_neq_down NEQ.

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

1 subgoal (ID 2243)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  j : Job
  H_arrives_in : arrives_in arr_seq j
  H_job_ready_sched' : job_ready sched' j t
  H_search_result_none : search_result = None
  ============================
  service sched j (job_deadline j) < job_cost j

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


            by apply j_misses_deadline.

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

No more subgoals.

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


        Qed.

      End MakeWCAtFindsReadyJobs_CaseResultNone.

Next, we show that [make_wc_at] always manages to establish the work-conservation property at the given time. Using the above case analysis, we can conclude that the presence of a ready job always leads to a valid swap.
      Lemma mwa_finds_ready_jobs:
        all_deadlines_of_arrivals_met arr_seq sched
        is_work_conserving_at sched' t.

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

1 subgoal (ID 2163)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ============================
  all_deadlines_of_arrivals_met arr_seq sched ->
  is_work_conserving_at sched' t

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


      Proof.
        moveALL_DL_MET P_PREFIX.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2166)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : exists j : Job, arrives_in arr_seq j /\ job_ready sched' j t
  ============================
  exists j : Job, sched' t = Some j

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


        destruct (sched t) as [j'|] eqn:SCHED_WC_t;
          first by rewrite /sched' /make_wc_at SCHED_WC_t; j'.

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

1 subgoal (ID 2178)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : exists j : Job, arrives_in arr_seq j /\ job_ready sched' j t
  SCHED_WC_t : sched t = None
  ============================
  exists j : Job, sched' t = Some j

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


        move: P_PREFIX ⇒ [j [ARR_IN READY]].

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

1 subgoal (ID 2213)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  SCHED_WC_t : sched t = None
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  ============================
  exists j0 : Job, sched' t = Some j0

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


        rewrite /sched' /make_wc_at.

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

1 subgoal (ID 2221)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  SCHED_WC_t : sched t = None
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  ============================
  exists j0 : Job,
    match sched t with
    | Some _ => sched
    | None => swapped sched t (find_swap_candidate arr_seq sched t)
    end t = Some j0

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


        rewrite SCHED_WC_t /find_swap_candidate.

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

1 subgoal (ID 2230)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  SCHED_WC_t : sched t = None
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  ============================
  exists j0 : Job,
    swapped sched t
      match
        search_arg sched (relevant_pstate t) (fun=> xpred0) t
          (max_deadline_for_jobs_arrived_before arr_seq t)
      with
      | Some t_swap => t_swap
      | None => t
      end t = Some j0

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


        destruct search_arg as [t_swap| ] eqn:SEARCH_RES.

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

2 subgoals (ID 2249)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  SCHED_WC_t : sched t = None
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  t_swap : nat
  SEARCH_RES : search_arg sched (relevant_pstate t) 
                 (fun=> xpred0) t
                 (max_deadline_for_jobs_arrived_before arr_seq t) =
               Some t_swap
  ============================
  exists j0 : Job, swapped sched t t_swap t = Some j0

subgoal 2 (ID 2250) is:
 exists j0 : Job, swapped sched t t t = Some j0

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


        - by apply make_wc_at_case_result_found; move:SCHED_WC_t ⇒ /eqP.

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

1 subgoal (ID 2250)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  max_dl := max_deadline_for_jobs_arrived_before arr_seq t : nat
  ALL_DL_MET : all_deadlines_of_arrivals_met arr_seq sched
  SCHED_WC_t : sched t = None
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  SEARCH_RES : search_arg sched (relevant_pstate t) 
                 (fun=> xpred0) t
                 (max_deadline_for_jobs_arrived_before arr_seq t) = None
  ============================
  exists j0 : Job, swapped sched t t t = Some j0

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


        - by exfalso; apply (make_wc_at_case_result_none j); eauto.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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


      Qed.

    End MakeWCAtFindsReadyJobs.

Next we prove that, given a schedule that respects the work-conservation property until [t-1], applying the point-wise transformation at time [t] will extend the property until [t].
    Lemma mwa_establishes_wc:
      all_deadlines_of_arrivals_met arr_seq sched
      ( t_l, t_l < t is_work_conserving_at sched t_l)
       t_l, t_l t is_work_conserving_at sched' t_l.

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

1 subgoal (ID 2154)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  all_deadlines_of_arrivals_met arr_seq sched ->
  (forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l) ->
  forall t_l : nat, t_l <= t -> is_work_conserving_at sched' t_l

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


    Proof.
      movePROP P_PREFIX t' T_MIN [j [ARR_IN READY]].

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

1 subgoal (ID 2180)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  ============================
  exists j0 : Job, sched' t' = Some j0

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


      set fsc := find_swap_candidate arr_seq sched t.

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

1 subgoal (ID 2185)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  ============================
  exists j0 : Job, sched' t' = Some j0

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


      have LEQ_fsc: t fsc by apply swap_candidate_is_in_future.

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

1 subgoal (ID 2188)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  ============================
  exists j0 : Job, sched' t' = Some j0

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


      destruct (ltnP t' t) as [tLT | tGE].
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2211)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  ============================
  exists j0 : Job, sched' t' = Some j0

subgoal 2 (ID 2212) is:
 exists j0 : Job, sched' t' = Some j0

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


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

1 subgoal (ID 2211)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  ============================
  exists j0 : Job, sched' t' = Some j0

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


have SAME: sched' t' = sched t'.

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

2 subgoals (ID 2215)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  ============================
  sched' t' = sched t'

subgoal 2 (ID 2217) is:
 exists j0 : Job, sched' t' = Some j0

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


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

1 subgoal (ID 2215)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  ============================
  sched' t' = sched t'

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


rewrite /sched' /make_wc_at.

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

1 subgoal (ID 2225)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  ============================
  match sched t with
  | Some _ => sched
  | None => swapped sched t (find_swap_candidate arr_seq sched t)
  end t' = sched t'

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


          destruct (sched t); first by done.

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

1 subgoal (ID 2233)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  ============================
  swapped sched t (find_swap_candidate arr_seq sched t) t' = sched t'

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


            by rewrite (swap_before_invariant sched t fsc) //.
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2217)

subgoal 1 (ID 2217) is:
 exists j0 : Job, sched' t' = Some j0
subgoal 2 (ID 2212) is:
 exists j0 : Job, sched' t' = Some j0

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


}

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

1 subgoal (ID 2217)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  SAME : sched' t' = sched t'
  ============================
  exists j0 : Job, sched' t' = Some j0

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


        rewrite SAME.

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

1 subgoal (ID 2245)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  SAME : sched' t' = sched t'
  ============================
  exists j0 : Job, sched t' = Some j0

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


        apply P_PREFIX; eauto.

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

1 subgoal (ID 2247)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  SAME : sched' t' = sched t'
  ============================
  exists j0 : Job, arrives_in arr_seq j0 /\ job_ready sched j0 t'

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


         j; split; auto.

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

1 subgoal (ID 2286)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tLT : t' < t
  SAME : sched' t' = sched t'
  ============================
  job_ready sched j t'

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


          by eapply mwa_ready_job_also_ready_in_original_schedule, READY.

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

1 subgoal (ID 2212)

subgoal 1 (ID 2212) is:
 exists j0 : Job, sched' t' = Some j0

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


      }

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

1 subgoal (ID 2212)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tGE : t <= t'
  ============================
  exists j0 : Job, sched' t' = Some j0

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


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

1 subgoal (ID 2212)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tGE : t <= t'
  ============================
  exists j0 : Job, sched' t' = Some j0

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


have EQ: t' = t.

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

2 subgoals (ID 2299)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tGE : t <= t'
  ============================
  t' = t

subgoal 2 (ID 2301) is:
 exists j0 : Job, sched' t' = Some j0

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


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

1 subgoal (ID 2299)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tGE : t <= t'
  ============================
  t' = t

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


by apply /eqP; rewrite eqn_leq; apply /andP; split.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2301)

subgoal 1 (ID 2301) is:
 exists j0 : Job, sched' t' = Some j0

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


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

1 subgoal (ID 2301)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  t' : nat
  T_MIN : t' <= t
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t'
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  tGE : t <= t'
  EQ : t' = t
  ============================
  exists j0 : Job, sched' t' = Some j0

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



        subst t'; clear T_MIN tGE.

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

1 subgoal (ID 2398)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  ============================
  exists j0 : Job, sched' t = Some j0

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


        apply mwa_finds_ready_jobs ⇒ //.

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

1 subgoal (ID 2401)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  PROP : all_deadlines_of_arrivals_met arr_seq sched
  P_PREFIX : forall t_l : nat, t_l < t -> is_work_conserving_at sched t_l
  j : Job
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched' j t
  fsc := find_swap_candidate arr_seq sched t : nat
  LEQ_fsc : t <= fsc
  ============================
  exists j0 : Job, arrives_in arr_seq j0 /\ job_ready sched' j0 t

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


          by j; split; eauto.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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


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

No more subgoals.

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



    Qed.

We now show that the point-wise transformation does not introduce any new job that does not come from the arrival sequence.
    Lemma mwa_jobs_come_from_arrival_sequence:
      jobs_come_from_arrival_sequence sched arr_seq
      jobs_come_from_arrival_sequence sched' arr_seq.

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

1 subgoal (ID 2161)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  jobs_come_from_arrival_sequence sched arr_seq ->
  jobs_come_from_arrival_sequence sched' arr_seq

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


    Proof.
      rewrite /sched' /make_wc_at.

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

1 subgoal (ID 2169)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  jobs_come_from_arrival_sequence sched arr_seq ->
  jobs_come_from_arrival_sequence
    match sched t with
    | Some _ => sched
    | None => swapped sched t (find_swap_candidate arr_seq sched t)
    end arr_seq

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


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

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

1 subgoal (ID 2183)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  SCHED_orig : sched t = None
  ============================
  jobs_come_from_arrival_sequence sched arr_seq ->
  jobs_come_from_arrival_sequence
    (swapped sched t (find_swap_candidate arr_seq sched t)) arr_seq

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


      by apply swapped_jobs_come_from_arrival_sequence.

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

No more subgoals.

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


    Qed.

We also show that the point-wise transformation does not schedule jobs in instants in which they are not ready.
    Lemma mwa_jobs_must_be_ready_to_execute:
      jobs_must_be_ready_to_execute sched
      jobs_must_be_ready_to_execute sched'.

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

1 subgoal (ID 2174)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  jobs_must_be_ready_to_execute sched -> jobs_must_be_ready_to_execute sched'

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


    Proof.
      moveREADY.

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

1 subgoal (ID 2175)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  READY : jobs_must_be_ready_to_execute sched
  ============================
  jobs_must_be_ready_to_execute sched'

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


      rewrite /sched' /make_wc_at.

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

1 subgoal (ID 2183)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  READY : jobs_must_be_ready_to_execute sched
  ============================
  jobs_must_be_ready_to_execute
    match sched t with
    | Some _ => sched
    | None => swapped sched t (find_swap_candidate arr_seq sched t)
    end

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


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

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

1 subgoal (ID 2197)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  READY : jobs_must_be_ready_to_execute sched
  SCHED_orig : sched t = None
  ============================
  jobs_must_be_ready_to_execute
    (swapped sched t (find_swap_candidate arr_seq sched t))

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


      by apply fsc_jobs_must_be_ready_to_execute.

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

No more subgoals.

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


    Qed.

Finally, we show that the point-wise transformation does not introduce deadline misses.
    Lemma mwa_all_deadlines_of_arrivals_met:
      all_deadlines_of_arrivals_met arr_seq sched
      all_deadlines_of_arrivals_met arr_seq sched'.

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

1 subgoal (ID 2187)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ============================
  all_deadlines_of_arrivals_met arr_seq sched ->
  all_deadlines_of_arrivals_met arr_seq sched'

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


    Proof.
      moveALL j ARR.

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

1 subgoal (ID 2191)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  ALL : all_deadlines_of_arrivals_met arr_seq sched
  j : Job
  ARR : arrives_in arr_seq j
  ============================
  job_meets_deadline sched' j

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


      specialize (ALL j ARR).

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

1 subgoal (ID 2193)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  ALL : job_meets_deadline sched j
  ARR : arrives_in arr_seq j
  ============================
  job_meets_deadline sched' j

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


      unfold job_meets_deadline, completed_by in ×.

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

1 subgoal (ID 2195)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  t : instant
  sched' := make_wc_at arr_seq sched t : nat -> option Job
  j : Job
  ALL : job_cost j <= service sched j (job_deadline j)
  ARR : arrives_in arr_seq j
  ============================
  job_cost j <= service sched' j (job_deadline j)

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


      by apply (leq_trans ALL (mwa_service_bound _ _)).

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

No more subgoals.

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


    Qed.

  End MakeWCAtFacts.

In the following section, we proceed by proving some useful properties respected by the partial schedule obtained by applying the work-conservation transformation up to an arbitrary horizon.
  Section PrefixFacts.

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

We start by proving that the transformation performed with two different horizons will yield two schedules that are identical until the earlier horizon.
    Section PrefixInclusion.

Consider two horizons...
      Variable h1 h2: instant.

...and assume w.l.o.g. that they are ordered...
      Hypothesis H_horizon_order: h1 h2.

...we define two schedules, resulting from the transformation performed, respectively, until the first and the second horizon.
Then, we show that the two schedules are guaranteed to be equal until the earlier horizon.
      Lemma wc_transform_prefix_inclusion:
         t, t < h1 sched1 t = sched2 t.

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

1 subgoal (ID 2114)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  H_horizon_order : h1 <= h2
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched h2
   : schedule (option_eqType Job)
  ============================
  forall t : nat, t < h1 -> sched1 t = sched2 t

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


      Proof.
        movet before_horizon.

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

1 subgoal (ID 2116)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  H_horizon_order : h1 <= h2
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched h2
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  ============================
  sched1 t = sched2 t

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


        rewrite /sched1 /sched2.

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

1 subgoal (ID 2118)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  H_horizon_order : h1 <= h2
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched h2
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  ============================
  wc_transform_prefix arr_seq sched h1 t =
  wc_transform_prefix arr_seq sched h2 t

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


        induction h2; first by move: (ltn_leq_trans before_horizon H_horizon_order).

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

1 subgoal (ID 2154)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  ============================
  wc_transform_prefix arr_seq sched h1 t =
  wc_transform_prefix arr_seq sched (succn i) t

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


        move: H_horizon_order.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2183)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  ============================
  h1 <= succn i ->
  wc_transform_prefix arr_seq sched h1 t =
  wc_transform_prefix arr_seq sched (succn i) t

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


rewrite leq_eqVlt ⇒ /orP [/eqP ->|LT]; first by done.

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

1 subgoal (ID 2266)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  LT : h1 < succn i
  ============================
  wc_transform_prefix arr_seq sched h1 t =
  wc_transform_prefix arr_seq sched (succn i) t

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


        move: LT.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2268)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  ============================
  h1 < succn i ->
  wc_transform_prefix arr_seq sched h1 t =
  wc_transform_prefix arr_seq sched (succn i) t

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


rewrite ltnSH_horizon_order_lt.

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

1 subgoal (ID 2273)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  H_horizon_order_lt : h1 <= i
  ============================
  wc_transform_prefix arr_seq sched h1 t =
  wc_transform_prefix arr_seq sched (succn i) t

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


        rewrite [RHS]/wc_transform_prefix /prefix_map -/prefix_map IHi //.

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

1 subgoal (ID 2297)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  H_horizon_order_lt : h1 <= i
  ============================
  wc_transform_prefix arr_seq sched i t =
  make_wc_at arr_seq (prefix_map sched (make_wc_at arr_seq) i) i t

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


        rewrite {1}/make_wc_at.

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

1 subgoal (ID 2327)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  H_horizon_order_lt : h1 <= i
  ============================
  wc_transform_prefix arr_seq sched i t =
  match prefix_map sched (make_wc_at arr_seq) i i with
  | Some _ => prefix_map sched (make_wc_at arr_seq) i
  | None =>
      swapped (prefix_map sched (make_wc_at arr_seq) i) i
        (find_swap_candidate arr_seq
           (prefix_map sched (make_wc_at arr_seq) i) i)
  end t

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


        destruct (prefix_map sched (make_wc_at arr_seq) i i) as [j|] eqn:SCHED; first by done.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2346)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  H_horizon_order_lt : h1 <= i
  SCHED : prefix_map sched (make_wc_at arr_seq) i i = None
  ============================
  wc_transform_prefix arr_seq sched i t =
  swapped (prefix_map sched (make_wc_at arr_seq) i) i
    (find_swap_candidate arr_seq (prefix_map sched (make_wc_at arr_seq) i) i)
    t

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



        rewrite -(swap_before_invariant _ i (find_swap_candidate arr_seq (wc_transform_prefix arr_seq sched i) i));
          last by apply ltn_leq_trans with (n := h1).

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

2 subgoals (ID 2369)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  H_horizon_order_lt : h1 <= i
  SCHED : prefix_map sched (make_wc_at arr_seq) i i = None
  ============================
  wc_transform_prefix arr_seq sched i t =
  prefix_map sched (make_wc_at arr_seq) i t

subgoal 2 (ID 2370) is:
 i <= find_swap_candidate arr_seq (wc_transform_prefix arr_seq sched i) i

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


        rewrite //.

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

1 subgoal (ID 2370)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h1, h2 : instant
  i : nat
  H_horizon_order : h1 <= succn i
  sched1 := wc_transform_prefix arr_seq sched h1
   : schedule (option_eqType Job)
  sched2 := wc_transform_prefix arr_seq sched (succn i)
   : schedule (option_eqType Job)
  t : nat
  before_horizon : t < h1
  IHi : h1 <= i ->
        let sched2 := wc_transform_prefix arr_seq sched i in
        wc_transform_prefix arr_seq sched h1 t =
        wc_transform_prefix arr_seq sched i t
  H_horizon_order_lt : h1 <= i
  SCHED : prefix_map sched (make_wc_at arr_seq) i i = None
  ============================
  i <= find_swap_candidate arr_seq (wc_transform_prefix arr_seq sched i) i

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


        apply swap_candidate_is_in_future.

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

No more subgoals.

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


      Qed.

    End PrefixInclusion.

Next, we show that repeating the point-wise transformation up to a given horizon does not introduce any deadline miss.
    Section JobsMeetDeadlinePrefix.

Assuming that all deadlines of jobs coming from the arrival sequence are met...
...let us define [sched'] as the schedule resulting from the full work-conservation transformation. Note that, if the schedule is sampled at time [t], the transformation is performed until [t+1].
      Let sched' := wc_transform arr_seq sched.

Consider a job from the arrival sequence.
      Variable j: Job.
      Hypothesis H_arrives_in: arrives_in arr_seq j.

We show that, in the transformed schedule, the service of the job is always greater or equal than in the original one, at any given time.
      Lemma wc_prefix_service_bound:
         t, service sched j t service sched' j t.

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

1 subgoal (ID 2122)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  ============================
  forall t : instant, service sched j t <= service sched' j t

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


      Proof.
        movet.

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

1 subgoal (ID 2123)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  ============================
  service sched j t <= service sched' j t

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


        rewrite /sched' /wc_transform.

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

1 subgoal (ID 2131)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  ============================
  service sched j t <=
  service (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0) j
    t

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


        set serv := service (fun t0 : instantwc_transform_prefix arr_seq sched t0.+1 t0) j t.

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

1 subgoal (ID 2139)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  ============================
  service sched j t <= serv

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


        set servp := service (wc_transform_prefix arr_seq sched t.+1) j t.

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

1 subgoal (ID 2147)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  ============================
  service sched j t <= serv

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


        have ->: serv = servp.
(* ----------------------------------[ coqtop ]---------------------------------

2 subgoals (ID 2150)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  ============================
  serv = servp

subgoal 2 (ID 2155) is:
 service sched j t <= servp

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


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

1 subgoal (ID 2150)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  ============================
  serv = servp

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


rewrite /serv /servp /service /service_during.

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

1 subgoal (ID 2171)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  ============================
  \sum_(0 <= t0 < t)
     service_at
       (fun t1 : instant => wc_transform_prefix arr_seq sched (succn t1) t1)
       j t0 =
  \sum_(0 <= t0 < t)
     service_at (wc_transform_prefix arr_seq sched (succn t)) j t0

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


          apply eq_big_natt' /andP [_ LT_t].

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

1 subgoal (ID 2213)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  t' : nat
  LT_t : t' < t
  ============================
  service_at
    (fun t0 : instant => wc_transform_prefix arr_seq sched (succn t0) t0) j
    t' = service_at (wc_transform_prefix arr_seq sched (succn t)) j t'

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


          rewrite /service_at.

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

1 subgoal (ID 2220)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  t' : nat
  LT_t : t' < t
  ============================
  service_in j (wc_transform_prefix arr_seq sched (succn t') t') =
  service_in j (wc_transform_prefix arr_seq sched (succn t) t')

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


          rewrite (wc_transform_prefix_inclusion t'.+1 t.+1)=> //.

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

1 subgoal (ID 2226)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  t' : nat
  LT_t : t' < t
  ============================
  t' < succn t

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


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

1 subgoal (ID 2155)

subgoal 1 (ID 2155) is:
 service sched j t <= servp

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


}

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

1 subgoal (ID 2155)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  ============================
  service sched j t <= servp

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


        rewrite /servp /wc_transform_prefix.

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

1 subgoal (ID 2258)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  serv := service
            (fun t0 : instant =>
             wc_transform_prefix arr_seq sched (succn t0) t0) j t : nat
  servp := service (wc_transform_prefix arr_seq sched (succn t)) j t : nat
  ============================
  service sched j t <=
  service (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


        clear serv servp.

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

1 subgoal (ID 2259)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  ============================
  service sched j t <=
  service (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


        apply prefix_map_property_invariance; last by done.

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

1 subgoal (ID 2261)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t0 : instant),
  service sched j t <= service sched0 j t ->
  service sched j t <= service (make_wc_at arr_seq sched0 t0) j t

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


        intros.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2265)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  sched0 : schedule (option_eqType Job)
  t0 : instant
  H2 : service sched j t <= service sched0 j t
  ============================
  service sched j t <= service (make_wc_at arr_seq sched0 t0) j t

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


apply leq_trans with (service sched0 j t)=> //.

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

1 subgoal (ID 2270)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  t : instant
  sched0 : schedule (option_eqType Job)
  t0 : instant
  H2 : service sched j t <= service sched0 j t
  ============================
  service sched0 j t <= service (make_wc_at arr_seq sched0 t0) j t

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


        by intros; apply mwa_service_bound.

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

No more subgoals.

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


      Qed.

Finally, it follows directly that the transformed schedule cannot introduce a deadline miss for any job from the arrival sequence.
      Lemma wc_prefix_job_meets_deadline:
        job_meets_deadline sched' j.

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

1 subgoal (ID 2128)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  ============================
  job_meets_deadline sched' j

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


      Proof.
        rewrite /job_meets_deadline /completed_by /sched'.

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

1 subgoal (ID 2143)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  ============================
  job_cost j <= service (wc_transform arr_seq sched) j (job_deadline j)

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


        apply leq_trans with (service sched j (job_deadline j));
          last by apply wc_prefix_service_bound.

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

1 subgoal (ID 2149)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched' := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  H_arrives_in : arrives_in arr_seq j
  ============================
  job_cost j <= service sched j (job_deadline j)

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


        by apply H_all_deadlines_of_arrivals_met.

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

No more subgoals.

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


      Qed.

    End JobsMeetDeadlinePrefix.

Next, consider a given time, used as horizon for the transformation...
    Variable h: instant.

...and let us call [sched'] the schedule resulting from the transformation performed until [h].
We prove that [sched'] will never introduce jobs not coming from the arrival sequence.
    Lemma wc_prefix_jobs_come_from_arrival_sequence:
      jobs_come_from_arrival_sequence sched arr_seq
      jobs_come_from_arrival_sequence sched' arr_seq.

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

1 subgoal (ID 2114)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  ============================
  jobs_come_from_arrival_sequence sched arr_seq ->
  jobs_come_from_arrival_sequence sched' arr_seq

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


    Proof.
      moveFROM_ARR.

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

1 subgoal (ID 2115)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  FROM_ARR : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence sched' arr_seq

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


      rewrite /sched' /wc_transform_prefix.

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

1 subgoal (ID 2123)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  FROM_ARR : jobs_come_from_arrival_sequence sched arr_seq
  ============================
  jobs_come_from_arrival_sequence (prefix_map sched (make_wc_at arr_seq) h)
    arr_seq

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


      apply prefix_map_property_invariance; last by done.

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

1 subgoal (ID 2125)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  FROM_ARR : 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_wc_at arr_seq sched0 t) arr_seq

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


      moveschedX t ARR.

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

1 subgoal (ID 2129)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  FROM_ARR : 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_wc_at arr_seq schedX t) arr_seq

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


      by apply mwa_jobs_come_from_arrival_sequence.

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

No more subgoals.

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


    Qed.

Similarly, we can show that [sched'] will only schedule jobs if they are ready.
    Lemma wc_prefix_jobs_must_be_ready_to_execute:
      jobs_must_be_ready_to_execute sched
      jobs_must_be_ready_to_execute sched'.

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

1 subgoal (ID 2127)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  ============================
  jobs_must_be_ready_to_execute sched -> jobs_must_be_ready_to_execute sched'

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


    Proof.
      moveREADY.

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

1 subgoal (ID 2128)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  READY : jobs_must_be_ready_to_execute sched
  ============================
  jobs_must_be_ready_to_execute sched'

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


      rewrite /sched' /wc_transform_prefix.

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

1 subgoal (ID 2136)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  READY : jobs_must_be_ready_to_execute sched
  ============================
  jobs_must_be_ready_to_execute (prefix_map sched (make_wc_at arr_seq) h)

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


      apply prefix_map_property_invariance; last by done.

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

1 subgoal (ID 2138)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  READY : jobs_must_be_ready_to_execute sched
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t : instant),
  jobs_must_be_ready_to_execute sched0 ->
  jobs_must_be_ready_to_execute (make_wc_at arr_seq sched0 t)

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


      moveschedX t ARR.

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

1 subgoal (ID 2142)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline Job
  arr_seq : arrival_sequence Job
  H_arr_seq_valid : valid_arrival_sequence arr_seq
  sched : schedule (processor_state Job)
  h : instant
  sched' := wc_transform_prefix arr_seq sched h
   : schedule (option_eqType Job)
  READY : jobs_must_be_ready_to_execute sched
  schedX : schedule (option_eqType Job)
  t : instant
  ARR : jobs_must_be_ready_to_execute schedX
  ============================
  jobs_must_be_ready_to_execute (make_wc_at arr_seq schedX t)

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


      by apply mwa_jobs_must_be_ready_to_execute.

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

No more subgoals.

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


    Qed.

  End PrefixFacts.

End AuxiliaryLemmasWorkConservingTransformation.

Finally, we can leverage all the previous results to prove statements about the full work-conservation transformation.
Consider any type of jobs with arrival times, costs, and deadlines...
  Context {Job : JobType}.
  Context `{JobArrival Job}.
  Context `{JobCost Job}.
  Context `{JobDeadline Job}.

...an arbitrary valid arrival sequence...
...and an ideal uniprocessor schedule...
...in which jobs come from the arrival sequence, and must be ready to execute...
...and in which no job misses a deadline.
Let us call [sched_wc] the schedule obtained after applying the work-conservation transformation.
First, we show that any scheduled job still comes from the arrival sequence.
  Lemma wc_jobs_come_from_arrival_sequence:
    jobs_come_from_arrival_sequence sched_wc arr_seq.

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

1 subgoal (ID 2103)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  jobs_come_from_arrival_sequence sched_wc arr_seq

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


  Proof.
    rewrite /sched_wc /wc_transform.

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

1 subgoal (ID 2111)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  jobs_come_from_arrival_sequence
    (fun t : nat => wc_transform_prefix arr_seq sched (succn t) t) arr_seq

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


    movej t.

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

1 subgoal (ID 2114)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ============================
  scheduled_at
    (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0) j t ->
  arrives_in arr_seq j

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


    move: H_sched_valid ⇒ [ARR READY].

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

1 subgoal (ID 2126)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  scheduled_at
    (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0) j t ->
  arrives_in arr_seq j

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


    rewrite /scheduled_at -/(scheduled_at _ j t).

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

1 subgoal (ID 2144)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t ->
  arrives_in arr_seq j

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


    by apply (wc_prefix_jobs_come_from_arrival_sequence arr_seq sched t.+1 ARR).

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

No more subgoals.

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


  Qed.

Similarly, jobs are only scheduled if they are ready.
  Lemma wc_jobs_must_be_ready_to_execute:
    jobs_must_be_ready_to_execute sched_wc.

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

1 subgoal (ID 2110)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  jobs_must_be_ready_to_execute sched_wc

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


  Proof.
    movej t.

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

1 subgoal (ID 2113)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ============================
  scheduled_at sched_wc j t -> job_ready sched_wc j t

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


    move: H_sched_valid ⇒ [ARR READY].

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

1 subgoal (ID 2125)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  ============================
  scheduled_at sched_wc j t -> job_ready sched_wc j t

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


    rewrite /scheduled_at /sched_wc /wc_transform -/(scheduled_at _ j t) ⇒ SCHED_AT.

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

1 subgoal (ID 2152)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  ============================
  job_ready (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0)
    j t

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


    have READY': job_ready (wc_transform_prefix arr_seq sched t.+1) j t
      by apply wc_prefix_jobs_must_be_ready_to_execute ⇒ //.

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

1 subgoal (ID 2170)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  READY' : job_ready (wc_transform_prefix arr_seq sched (succn t)) j t
  ============================
  job_ready (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0)
    j t

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


    move: READY'.

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

1 subgoal (ID 2172)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  ============================
  job_ready (wc_transform_prefix arr_seq sched (succn t)) j t ->
  job_ready (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0)
    j t

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


    rewrite /job_ready /basic.basic_ready_instance
            /pending /completed_by /service.

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

1 subgoal (ID 2217)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  ============================
  has_arrived j t &&
  ~~
  (job_cost j <=
   service_during (wc_transform_prefix arr_seq sched (succn t)) j 0 t) ->
  has_arrived j t &&
  ~~
  (job_cost j <=
   service_during
     (fun t0 : nat => wc_transform_prefix arr_seq sched (succn t0) t0) j 0 t)

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


    rewrite (equal_prefix_implies_same_service_during sched_wc (wc_transform_prefix arr_seq sched t.+1)) //.

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

1 subgoal (ID 2236)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  ============================
  forall t0 : nat,
  0 <= t0 < t -> sched_wc t0 = wc_transform_prefix arr_seq sched (succn t) t0

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


    movet' /andP [_ BOUND_t'].

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

1 subgoal (ID 2304)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  t' : nat
  BOUND_t' : t' < t
  ============================
  sched_wc t' = wc_transform_prefix arr_seq sched (succn t) t'

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


    rewrite /sched_wc /wc_transform.

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

1 subgoal (ID 2312)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR : jobs_come_from_arrival_sequence sched arr_seq
  READY : jobs_must_be_ready_to_execute sched
  SCHED_AT : scheduled_at (wc_transform_prefix arr_seq sched (succn t)) j t
  t' : nat
  BOUND_t' : t' < t
  ============================
  wc_transform_prefix arr_seq sched (succn t') t' =
  wc_transform_prefix arr_seq sched (succn t) t'

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


    by apply wc_transform_prefix_inclusion ⇒ //; rewrite ltnS; apply ltnW.

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

No more subgoals.

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


  Qed.

Also, no deadline misses are introduced.
  Lemma wc_all_deadlines_of_arrivals_met:
    all_deadlines_of_arrivals_met arr_seq sched_wc.

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

1 subgoal (ID 2116)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  all_deadlines_of_arrivals_met arr_seq sched_wc

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


  Proof.
    movej ARR_IN.

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

1 subgoal (ID 2119)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  ARR_IN : arrives_in arr_seq j
  ============================
  job_meets_deadline sched_wc j

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


    rewrite /sched_wc /wc_transform_prefix.

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

1 subgoal (ID 2127)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  ARR_IN : arrives_in arr_seq j
  ============================
  job_meets_deadline (wc_transform arr_seq sched) j

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


    by apply wc_prefix_job_meets_deadline.

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

No more subgoals.

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


  Qed.

Finally, we can show that the transformation leads to a schedule in which the processor is not idle if a job is ready.
  Lemma wc_is_work_conserving_at:
     j t,
      job_ready sched_wc j t
      arrives_in arr_seq j
       j', sched_wc t = Some j'.

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

1 subgoal (ID 2135)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  forall (j : Job) (t : instant),
  job_ready sched_wc j t ->
  arrives_in arr_seq j -> exists j' : Job, sched_wc t = Some j'

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


  Proof.
    movej t READY ARR_IN.

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

1 subgoal (ID 2139)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  exists j' : Job, sched_wc t = Some j'

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


    rewrite /sched_wc /wc_transform /wc_transform_prefix.

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

1 subgoal (ID 2154)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  exists j' : Job,
    prefix_map sched (make_wc_at arr_seq) (succn t) t = Some j'

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


    apply (prefix_map_pointwise_property (all_deadlines_of_arrivals_met arr_seq)
                                         (is_work_conserving_at arr_seq)
                                         (make_wc_at arr_seq)); rewrite //.

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

3 subgoals (ID 2168)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t_ref : instant),
  all_deadlines_of_arrivals_met arr_seq sched0 ->
  all_deadlines_of_arrivals_met arr_seq (make_wc_at arr_seq sched0 t_ref)

subgoal 2 (ID 2169) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 all_deadlines_of_arrivals_met arr_seq sched0 ->
 (forall t' : nat, t' < t_ref -> is_work_conserving_at arr_seq sched0 t') ->
 forall t' : nat,
 t' <= t_ref ->
 is_work_conserving_at arr_seq (make_wc_at arr_seq sched0 t_ref) t'
subgoal 3 (ID 2172) is:
 exists j0 : Job,
   arrives_in arr_seq j0 /\
   job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j0 t

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


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

1 subgoal (ID 2168)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t_ref : instant),
  all_deadlines_of_arrivals_met arr_seq sched0 ->
  all_deadlines_of_arrivals_met arr_seq (make_wc_at arr_seq sched0 t_ref)

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


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

2 subgoals (ID 2169)

subgoal 1 (ID 2169) is:
 forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
 all_deadlines_of_arrivals_met arr_seq sched0 ->
 (forall t' : nat, t' < t_ref -> is_work_conserving_at arr_seq sched0 t') ->
 forall t' : nat,
 t' <= t_ref ->
 is_work_conserving_at arr_seq (make_wc_at arr_seq sched0 t_ref) t'
subgoal 2 (ID 2172) is:
 exists j0 : Job,
   arrives_in arr_seq j0 /\
   job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j0 t

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


}

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

2 subgoals (ID 2169)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
  all_deadlines_of_arrivals_met arr_seq sched0 ->
  (forall t' : nat, t' < t_ref -> is_work_conserving_at arr_seq sched0 t') ->
  forall t' : nat,
  t' <= t_ref ->
  is_work_conserving_at arr_seq (make_wc_at arr_seq sched0 t_ref) t'

subgoal 2 (ID 2172) is:
 exists j0 : Job,
   arrives_in arr_seq j0 /\
   job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j0 t

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


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

1 subgoal (ID 2169)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  forall (sched0 : schedule (option_eqType Job)) (t_ref : nat),
  all_deadlines_of_arrivals_met arr_seq sched0 ->
  (forall t' : nat, t' < t_ref -> is_work_conserving_at arr_seq sched0 t') ->
  forall t' : nat,
  t' <= t_ref ->
  is_work_conserving_at arr_seq (make_wc_at arr_seq sched0 t_ref) t'

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


by intros; apply mwa_establishes_wc.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2172)

subgoal 1 (ID 2172) is:
 exists j0 : Job,
   arrives_in arr_seq j0 /\
   job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j0 t

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


}

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

1 subgoal (ID 2172)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  exists j0 : Job,
    arrives_in arr_seq j0 /\
    job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j0 t

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


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

1 subgoal (ID 2172)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  exists j0 : Job,
    arrives_in arr_seq j0 /\
    job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j0 t

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


j.

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

1 subgoal (ID 2299)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  arrives_in arr_seq j /\
  job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


      split; first by apply ARR_IN.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2302)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


      have EQ: job_ready sched_wc j t = job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t.

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

2 subgoals (ID 2322)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  job_ready sched_wc j t =
  job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

subgoal 2 (ID 2324) is:
 job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


      {

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

1 subgoal (ID 2322)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  job_ready sched_wc j t =
  job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


        rewrite /sched_wc /wc_transform /job_ready
                /basic_ready_instance /pending /completed_by
                /service /service_during /service_at /wc_transform_prefix.

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

1 subgoal (ID 2398)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  has_arrived j t &&
  ~~
  (job_cost j <=
   \sum_(0 <= t0 < t)
      service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0)) =
  has_arrived j t &&
  ~~
  (job_cost j <=
   \sum_(0 <= t0 < t)
      service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0))

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


        destruct has_arrived; last by rewrite Bool.andb_false_l.

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

1 subgoal (ID 2409)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  true &&
  ~~
  (job_cost j <=
   \sum_(0 <= t0 < t)
      service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0)) =
  true &&
  ~~
  (job_cost j <=
   \sum_(0 <= t0 < t)
      service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0))

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


        have EQ_SUM: \sum_(0 t0 < t) service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0)
                  = \sum_(0 t0 < t) service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0).

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

2 subgoals (ID 2440)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0) =
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0)

subgoal 2 (ID 2442) is:
 true &&
 ~~
 (job_cost j <=
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0)) =
 true &&
 ~~
 (job_cost j <=
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0))

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


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

1 subgoal (ID 2440)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  ============================
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0) =
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0)

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


 apply eq_big_natt' /andP [_ LT_t].

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

1 subgoal (ID 2484)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  t' : nat
  LT_t : t' < t
  ============================
  service_in j (prefix_map sched (make_wc_at arr_seq) (succn t') t') =
  service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t')

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


           rewrite -/(wc_transform_prefix arr_seq sched _ _).

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

1 subgoal (ID 2497)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  t' : nat
  LT_t : t' < t
  ============================
  service_in j (wc_transform_prefix arr_seq sched (succn t') t') =
  service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t')

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


           rewrite -/(wc_transform_prefix arr_seq sched _ _).
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2510)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  t' : nat
  LT_t : t' < t
  ============================
  service_in j (wc_transform_prefix arr_seq sched (succn t') t') =
  service_in j (wc_transform_prefix arr_seq sched (succn t) t')

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



           rewrite (wc_transform_prefix_inclusion arr_seq sched t'.+1 t.+1)=> //.

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

1 subgoal (ID 2522)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  t' : nat
  LT_t : t' < t
  ============================
  t' < succn t

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


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

2 subgoals (ID 2442)

subgoal 1 (ID 2442) is:
 true &&
 ~~
 (job_cost j <=
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0)) =
 true &&
 ~~
 (job_cost j <=
  \sum_(0 <= t0 < t)
     service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0))
subgoal 2 (ID 2324) is:
 job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


}

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

1 subgoal (ID 2442)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  EQ_SUM : \sum_(0 <= t0 < t)
              service_in j
                (prefix_map sched (make_wc_at arr_seq) (succn t0) t0) =
           \sum_(0 <= t0 < t)
              service_in j
                (prefix_map sched (make_wc_at arr_seq) (succn t) t0)
  ============================
  true &&
  ~~
  (job_cost j <=
   \sum_(0 <= t0 < t)
      service_in j (prefix_map sched (make_wc_at arr_seq) (succn t0) t0)) =
  true &&
  ~~
  (job_cost j <=
   \sum_(0 <= t0 < t)
      service_in j (prefix_map sched (make_wc_at arr_seq) (succn t) t0))

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


        by rewrite EQ_SUM.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2324)

subgoal 1 (ID 2324) is:
 job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


}

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

1 subgoal (ID 2324)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  READY : job_ready sched_wc j t
  ARR_IN : arrives_in arr_seq j
  EQ : job_ready sched_wc j t =
       job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t
  ============================
  job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


      move: READY.
(* ----------------------------------[ coqtop ]---------------------------------

1 subgoal (ID 2550)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR_IN : arrives_in arr_seq j
  EQ : job_ready sched_wc j t =
       job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t
  ============================
  job_ready sched_wc j t ->
  job_ready (prefix_map sched (make_wc_at arr_seq) (succn t)) j t

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


by rewrite EQ.
(* ----------------------------------[ coqtop ]---------------------------------

No more subgoals.

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


}

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

No more subgoals.

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


  Qed.

We can easily extend the previous lemma to obtain the definition of a work-conserving schedule.
  Lemma wc_is_work_conserving:
    work_conserving arr_seq sched_wc.

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

1 subgoal (ID 2142)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  work_conserving arr_seq sched_wc

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


  Proof.
    movej t ARR_IN.

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

1 subgoal (ID 2146)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR_IN : arrives_in arr_seq j
  ============================
  backlogged sched_wc j t ->
  exists j_other : Job, scheduled_at sched_wc j_other t

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


    rewrite /backlogged ⇒ /andP [READY _].

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

1 subgoal (ID 2199)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched_wc j t
  ============================
  exists j_other : Job, scheduled_at sched_wc j_other t

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


    move: (wc_is_work_conserving_at j t READY ARR_IN) ⇒ [j' SCHED_wc].

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

1 subgoal (ID 2211)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  j : Job
  t : instant
  ARR_IN : arrives_in arr_seq j
  READY : job_ready sched_wc j t
  j' : Job
  SCHED_wc : sched_wc t = Some j'
  ============================
  exists j_other : Job, scheduled_at sched_wc j_other t

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


    by j'; rewrite scheduled_at_def; apply /eqP.

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

No more subgoals.

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


  Qed.

Ultimately, we can show that the work-conservation transformation maintains all the properties of validity, does not introduce new deadline misses, and establishes the work-conservation property.
  Theorem wc_transform_correctness:
    valid_schedule sched_wc arr_seq
    all_deadlines_of_arrivals_met arr_seq sched_wc
    work_conserving arr_seq sched_wc.

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

1 subgoal (ID 2161)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  valid_schedule sched_wc arr_seq /\
  all_deadlines_of_arrivals_met arr_seq sched_wc /\
  work_conserving arr_seq sched_wc

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


  Proof.
    repeat split.

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

4 subgoals (ID 2166)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  jobs_come_from_arrival_sequence sched_wc arr_seq

subgoal 2 (ID 2167) is:
 jobs_must_be_ready_to_execute sched_wc
subgoal 3 (ID 2177) is:
 all_deadlines_of_arrivals_met arr_seq sched_wc
subgoal 4 (ID 2178) is:
 work_conserving arr_seq sched_wc

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


    - apply wc_jobs_come_from_arrival_sequence.

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

3 subgoals (ID 2167)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  jobs_must_be_ready_to_execute sched_wc

subgoal 2 (ID 2177) is:
 all_deadlines_of_arrivals_met arr_seq sched_wc
subgoal 3 (ID 2178) is:
 work_conserving arr_seq sched_wc

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


    - apply wc_jobs_must_be_ready_to_execute.

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

2 subgoals (ID 2177)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  all_deadlines_of_arrivals_met arr_seq sched_wc

subgoal 2 (ID 2178) is:
 work_conserving arr_seq sched_wc

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


    - apply wc_all_deadlines_of_arrivals_met.

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

1 subgoal (ID 2178)
  
  Job : JobType
  H : JobArrival Job
  H0 : JobCost Job
  H1 : JobDeadline 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
  H_all_deadlines_of_arrivals_met : all_deadlines_of_arrivals_met arr_seq
                                      sched
  sched_wc := wc_transform arr_seq sched : nat -> option_eqType Job
  ============================
  work_conserving arr_seq sched_wc

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


    - apply wc_is_work_conserving.

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

No more subgoals.

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


  Qed.

End WorkConservingTransformation.