| import OAI.Computability.Scheduling.FamilyRoutines |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 |
|
|
| section |
|
|
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
|
|
| instance {n : ℕ} (G : Instance n) : DecidableRel G.edge := fun a b => |
| inferInstanceAs (Decidable ((a,b) ∈ G.edges)) |
|
|
| instance (n : ℕ) : Coding (Instance n) := ⟨fun G => enc G.edges⟩ |
|
|
| @[simp] theorem enc_instance {n : ℕ} (G : Instance n) : enc G = enc G.edges := rfl |
|
|
| theorem enc_map_eq {α : Type u1} {β : Type u2} [Coding α] [Coding β] (f : α → β) |
| (h : ∀ a, enc (f a) = enc a) (xs : List α) : enc (xs.map f) = enc xs := by |
| induction xs with |
| | nil => rfl |
| | cons a xs ih => simp only [List.map_cons,enc_cons,h,ih] |
|
|
| namespace Uniform |
|
|
| variable {I : Type u3} {α : I → Type u4} [∀ i, Coding (α i)] |
|
|
| def matrixMapAny (d : I → ℕ) {p : ∀ i, (Fin (d i) × Fin (d i)) × α i → Bool} |
| (P : Uniform p) : Uniform (fun i (x : Universe (d i) × α i) => |
| (fun a b => p i ((a,b),x.2) : Matrix (d i))) := by |
| let A : Uniform (fun i (x : Fin (d i) × (Fin (d i) × α i)) => p i ((x.2.1,x.1),x.2.2)) := |
| (((snd.comp fst).pair fst).pair (snd.comp snd)).comp P |
| let B : Uniform (fun i (x : Fin (d i) × (Universe (d i) × α i)) => |
| fun b => p i ((x.1,b),x.2.2)) := |
| (((snd.comp fst).pair (fst.pair (snd.comp snd))).comp (A.vectorMapAny d)) |
| exact ((fst.pair id).comp (B.vectorMapAny d)).congr (fun _ _ => rfl) |
|
|
| def instanceEdges : Uniform (fun n (G : Instance n) => G.edges) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def edgePairEq : Uniform (fun n (x : (Fin n × Fin n) × (Fin n × Fin n)) => decide (x.1 = x.2)) := |
| (((fst.comp fst).pair (snd.comp fst)).comp finEq).andD |
| (((fst.comp snd).pair (snd.comp snd)).comp finEq) |>.congr (fun _ x => by |
| apply decide_eq_decide.mpr |
| change (x.1.1 = x.2.1 ∧ x.1.2 = x.2.2) ↔ x.1 = x.2 |
| exact Prod.ext_iff.symm) |
|
|
| def edgeAt : Uniform (fun n (x : (Fin n × Fin n) × Instance n) => decide (x.2.edge x.1.1 x.1.2)) := |
| ((((snd.comp instanceEdges).pair fst).comp edgePairEq.any)).congr (fun _ x => by |
| simp only [Function.comp_apply] |
| apply Bool.eq_iff_iff.mpr |
| rw [decide_eq_true_eq] |
| simp only [List.any_eq_true,decide_eq_true_eq] |
| change (∃ y ∈ x.2.edges, y = x.1) ↔ x.1 ∈ x.2.edges |
| exact exists_eq_right) |
|
|
| def edgeMatrix : Uniform (fun n (x : Universe n × Instance n) => |
| (fun a b => decide (x.2.edge a b) : Matrix n)) := matrixMapAny (fun n : ℕ => n) edgeAt |
|
|
| def matrixRows : Uniform (fun n (M : Matrix n) => (List.ofFn M).map List.ofFn) := |
| reinterpret _ (fun _ M => by |
| rw [enc_map_eq List.ofFn (fun _ => rfl)] |
| rfl) |
|
|
| def readMatrix {n : ℕ} (M : Matrix n) (a b : ℕ) : Bool := |
| (((List.ofFn M).map List.ofFn).getD a []).getD b Bool.false |
|
|
| def matrixReadNat : Uniform (fun n (x : Matrix n × (ℕ × ℕ)) => readMatrix x.1 x.2.1 x.2.2) := by |
| let A := ((((fst.comp matrixRows).pair (snd.comp fst)).pair nil).comp getElemD : |
| Uniform (fun n (x : Matrix n × (ℕ × ℕ)) => ((List.ofFn x.1).map List.ofFn).getD x.2.1 [])) |
| exact (((A.pair (snd.comp snd)).pair false).comp getElemD) |
|
|
| theorem readMatrix_eq {n : ℕ} (M : Matrix n) (a b : ℕ) : |
| readMatrix M a b = if ha : a < n then if hb : b < n then M ⟨a,ha⟩ ⟨b,hb⟩ else Bool.false else Bool.false := by |
| simp only [readMatrix,List.getD_eq_getElem?_getD,List.getElem?_map,List.getElem?_ofFn] |
| split_ifs <;> simp_all |
|
|
| def paddedMatrix : Uniform (fun (i : ℕ × ℕ) (x : Universe i.2 × Matrix i.1) => |
| (fun a b => decide (paddedOrder (matrixRel x.2) i.2 a b) : Matrix i.2)) := by |
| let P : Uniform (fun (i : ℕ × ℕ) (x : (Fin i.2 × Fin i.2) × Matrix i.1) => |
| readMatrix x.2 x.1.1.val x.1.2.val) := |
| (snd.pair (((fst.comp fst).comp (finValue Prod.snd)).pair |
| ((fst.comp snd).comp (finValue Prod.snd)))).comp (matrixReadNat.reindex Prod.fst) |
| exact (matrixMapAny Prod.snd P).congr (fun i x => by |
| funext a b |
| rw [readMatrix_eq] |
| by_cases ha : a.val < i.1 <;> by_cases hb : b.val < i.1 |
| · simp only [dite_eq_left ha,dite_eq_left hb] |
| apply Bool.eq_iff_iff.mpr |
| change (x.2 ⟨a.val,ha⟩ ⟨b.val,hb⟩ = true) ↔ |
| (decide (paddedOrder (matrixRel x.2) i.2 a b) = true) |
| rw [decide_eq_true_eq] |
| change (matrixRel x.2 ⟨a.val,ha⟩ ⟨b.val,hb⟩) ↔ paddedOrder (matrixRel x.2) i.2 a b |
| constructor |
| · intro h; exact ⟨⟨a.val,ha⟩,⟨b.val,hb⟩,rfl,rfl,h⟩ |
| · rintro ⟨u,v,hu,hv,h⟩ |
| have eu : u = ⟨a.val,ha⟩ := Fin.ext hu.symm |
| have ev : v = ⟨b.val,hb⟩ := Fin.ext hv.symm |
| simpa only [eu,ev] using h |
| · simp only [dite_eq_left ha,dite_eq_right hb] |
| have h : ¬paddedOrder (matrixRel x.2) i.2 a b := by |
| rintro ⟨u,v,hu,hv,hr⟩; exact hb (hv.symm ▸ v.isLt) |
| simp only [h,decide_false] |
| · simp only [dite_eq_right ha] |
| have h : ¬paddedOrder (matrixRel x.2) i.2 a b := by |
| rintro ⟨u,v,hu,hv,hr⟩; exact ha (hu.symm ▸ u.isLt) |
| simp only [h,decide_false] |
| · simp only [dite_eq_right ha] |
| have h : ¬paddedOrder (matrixRel x.2) i.2 a b := by |
| rintro ⟨u,v,hu,hv,hr⟩; exact ha (hu.symm ▸ u.isLt) |
| simp only [h,decide_false]) |
|
|
| end Uniform |
| end ThreeMachine.StackCompiler |
|
|
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
|
|
| def nextMatrix {n : ℕ} (E M : Matrix n) : Matrix n := |
| fun a b => M a b || (List.finRange n).any (fun z => M a z && E z b) |
|
|
| def closureMatrix {n : ℕ} (G : Instance n) (k : ℕ) : Matrix n := |
| fun a b => decide ((a,b) ∈ Algorithm.closureTable G k) |
|
|
| theorem closureMatrix_zero {n : ℕ} (G : Instance n) : |
| closureMatrix G 0 = fun a b => decide (G.edge a b) := by |
| funext a b |
| simp only [closureMatrix,Algorithm.closureTable_zero,List.mem_toFinset,Instance.edge] |
| rfl |
|
|
| theorem nextMatrix_closure {n : ℕ} (G : Instance n) (k : ℕ) : |
| nextMatrix (closureMatrix G 0) (closureMatrix G k) = closureMatrix G (k+1) := by |
| funext a b |
| apply Bool.eq_iff_iff.mpr |
| simp only [nextMatrix,closureMatrix,Bool.or_eq_true,Bool.and_eq_true,List.any_eq_true, |
| decide_eq_true_eq,List.mem_finRange] |
| simp only [Algorithm.closureTable_succ,Algorithm.closureTable_zero, |
| Algorithm.closureStep,Finset.mem_union,Finset.mem_filter,Finset.mem_univ,true_and] |
|
|
| namespace Uniform |
|
|
| def nextMatrixCell : Uniform (fun n (x : (Fin n × Fin n) × (Universe n × (Matrix n × Matrix n))) => |
| ThreeMachine.StackCompiler.nextMatrix x.2.2.1 x.2.2.2 x.1.1 x.1.2) := by |
| let P : Uniform (fun n (x : Fin n × ((Fin n × Fin n) × (Matrix n × Matrix n))) => |
| x.2.2.2 x.2.1.1 x.1 && x.2.2.1 x.1 x.2.1.2) := |
| (((((snd.comp (snd.comp snd)).pair (((snd.comp (fst.comp fst)).pair fst))).comp matrixGet).pair |
| (((snd.comp (snd.comp fst)).pair (fst.pair (snd.comp (fst.comp snd)))).comp matrixGet)).comp |
| (Realizer.and.uniform ℕ)) |
| let A := (((snd.comp (snd.comp snd)).pair fst).comp matrixGet : |
| Uniform (fun n (x : (Fin n × Fin n) × (Universe n × (Matrix n × Matrix n))) => |
| x.2.2.2 x.1.1 x.1.2)) |
| let B := ((((snd.comp fst).comp universeList).pair (fst.pair (snd.comp snd))).comp P.any) |
| exact ((A.pair B).comp (Realizer.or.uniform ℕ)).congr (fun _ _ => rfl) |
|
|
| def nextMatrix : Uniform (fun n (x : Universe n × (Matrix n × Matrix n)) => |
| ThreeMachine.StackCompiler.nextMatrix x.2.1 x.2.2) := |
| (fst.pair id).comp (matrixMapAny (fun n => n) nextMatrixCell) |
|
|
| def closureMatrixStep : Uniform (fun n (x : (Universe n × Matrix n) × Matrix n) => |
| (x.1,ThreeMachine.StackCompiler.nextMatrix x.1.2 x.2)) := |
| fst.pair ((((fst.comp fst).pair ((fst.comp snd).pair snd))).comp nextMatrix) |
|
|
| def reachMatrix : Uniform (fun n (x : Universe n × Instance n) => closureMatrix x.2 n) := by |
| let A := fst.pair edgeMatrix |
| let B := ((fst.comp universeNumber).pair (A.pair edgeMatrix)).comp closureMatrixStep.iterate |>.comp snd |
| exact B.congr (fun n x => by |
| dsimp only [Function.comp_apply] |
| have h : ∀ k, (fun p : (Universe n × Matrix n) × Matrix n => |
| (p.1,ThreeMachine.StackCompiler.nextMatrix p.1.2 p.2))^[k] |
| ((x.1,fun a b => decide (x.2.edge a b)),fun a b => decide (x.2.edge a b)) = |
| ((x.1,fun a b => decide (x.2.edge a b)),closureMatrix x.2 k) := by |
| intro k |
| induction k with |
| | zero => rw [Function.iterate_zero_apply,closureMatrix_zero] |
| | succ k ih => |
| rw [Function.iterate_succ_apply',ih] |
| simp only [← closureMatrix_zero,nextMatrix_closure] |
| rw [h]) |
| |
| end Uniform |
| end ThreeMachine.StackCompiler |
| |
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
| |
| namespace Realizer |
| |
| def triple : Realizer (fun n : ℕ => 3*n) := |
| (((id.pair id).comp add).pair id |>.comp add).congr (fun n => by |
| simp only [Function.comp_apply,id_eq] |
| omega) |
| |
| end Realizer |
| |
| def scheduleMatrix {n : ℕ} (M : Matrix n) (T : ℕ) : Option (Fin n → ℕ) := |
| if hn : n ≤ 3*T then |
| (Algorithm.fullSolve (paddedOrder (matrixRel M) (3*T))).map |
| (fun s x => s.time (Fin.castLE hn x)) |
| else none |
| |
| theorem scheduleMatrix_closure {n : ℕ} (G : Instance n) (T : ℕ) : |
| scheduleMatrix (closureMatrix G n) T = Algorithm.scheduleAt G T := by |
| have h : matrixRel (closureMatrix G n) = Algorithm.reachable G := by |
| funext a b |
| simp only [matrixRel,closureMatrix,decide_eq_true_eq,Algorithm.reachable] |
| simp only [scheduleMatrix,Algorithm.scheduleAt,h] |
| |
| namespace Uniform |
| |
| def restrictTime : Uniform (fun (i : ℕ × ℕ) (x : Universe i.1 × (Fin i.2 → ℕ)) => |
| (fun v : Fin i.1 => (List.ofFn x.2).getD v.val 0)) := by |
| let A : Uniform (fun (i : ℕ × ℕ) (x : Fin i.1 × (Fin i.2 → ℕ)) => |
| (List.ofFn x.2).getD x.1.val 0) := |
| ((((snd.comp (functionListAny Prod.snd)).pair (fst.comp (finValue Prod.fst))).pair zero).comp getElemD) |
| exact A.vectorMapAny Prod.fst |
| |
| def paddedSolve : Uniform (fun (i : ℕ × ℕ) (x : Cardinal i.2 × Matrix i.1) => |
| Algorithm.fullSolve (paddedOrder (matrixRel x.2) (3*i.2))) := by |
| let U : Uniform (fun (i : ℕ × ℕ) (_ : Cardinal i.2 × Matrix i.1) => |
| (Universe.mk () : Universe (3*i.2))) := (fst.comp (cardinalMap Prod.snd Realizer.triple)).comp |
| (makeUniverseAny (fun i : ℕ × ℕ => 3*i.2)) |
| let A := (U.pair snd).comp (paddedMatrix.reindex (fun i : ℕ × ℕ => (i.1,3*i.2))) |
| exact ((U.pair A).comp (fullSolve.reindex (fun i : ℕ × ℕ => 3*i.2))).congr (fun i x => by |
| have h : matrixRel (fun a b : Fin (3*i.2) => decide (paddedOrder (matrixRel x.2) (3*i.2) a b)) = |
| paddedOrder (matrixRel x.2) (3*i.2) := by |
| funext a b |
| exact propext (by simp only [matrixRel,decide_eq_true_eq]) |
| simp only [Function.comp_apply,h]) |
| |
| def scheduleMatrixFixed : Uniform (fun (i : ℕ × ℕ) |
| (x : Universe i.1 × (Cardinal i.2 × Matrix i.1)) => |
| ThreeMachine.StackCompiler.scheduleMatrix x.2.2 i.2) := by |
| let P : Uniform (fun (i : ℕ × ℕ) (_ : Universe i.1 × (Cardinal i.2 × Matrix i.1)) => |
| decide (i.1 ≤ 3*i.2)) := |
| (((fst.comp (universeNumber.reindex Prod.fst)).pair |
| ((snd.comp fst).comp (cardinalValue Prod.snd) |>.comp (Realizer.triple.uniform (ℕ × ℕ)))).comp |
| (Realizer.le.uniform (ℕ × ℕ))) |
| let R : Uniform (fun (i : ℕ × ℕ) (x : Algorithm.Block (Fin (3*i.2)) × Universe i.1) => |
| (fun v : Fin i.1 => (List.ofFn x.1.time).getD v.val 0)) := |
| (snd.pair (fst.comp (blockTime.reindex (fun i : ℕ × ℕ => 3*i.2)))).comp |
| (restrictTime.reindex (fun i : ℕ × ℕ => (i.1,3*i.2))) |
| let A := (((snd.comp paddedSolve).pair fst).comp R.optionMap) |
| exact ((P.pair id).comp (A.choose none)).congr (fun i x => by |
| simp only [Function.comp_apply,ThreeMachine.StackCompiler.scheduleMatrix] |
| by_cases h : i.1 ≤ 3*i.2 |
| · simp only [decide_eq_true_eq,ite_eq_left h,dite_eq_left h] |
| apply congrArg (fun f => Option.map f _) |
| funext b |
| funext v |
| simp only [List.getD_eq_getElem?_getD,List.getElem?_ofFn,dite_eq_left (lt_of_lt_of_le v.isLt h), |
| Option.getD_some] |
| rfl |
| · simp only [decide_eq_true_eq,ite_eq_right h,dite_eq_right h]) |
| |
| def scheduleMatrix : Uniform (fun n (x : Universe n × (ℕ × Matrix n)) => |
| ThreeMachine.StackCompiler.scheduleMatrix x.2.2 x.2.1) := |
| scheduleMatrixFixed.recode _ (fun n x => |
| ⟨(n,x.2.1),(x.1,(Cardinal.mk (),x.2.2)),rfl,rfl⟩) |
| |
| end Uniform |
| end ThreeMachine.StackCompiler |
| |
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
| |
| def bestMatrix {n : ℕ} (M : Matrix n) : ℕ → Option (ℕ × (Fin n → ℕ)) |
| | 0 => none |
| | k+1 => match bestMatrix M k with |
| | some a => some a |
| | none => (scheduleMatrix M (k+1)).map (fun t => (k+1,t)) |
| |
| theorem bestMatrix_closure {n : ℕ} (G : Instance n) (k : ℕ) : |
| bestMatrix (closureMatrix G n) k = Algorithm.best G k := by |
| induction k with |
| | zero => rfl |
| | succ k ih => |
| simp only [bestMatrix,Algorithm.best,ih,scheduleMatrix_closure] |
| cases Algorithm.best G k <;> rfl |
| |
| def bestMatrixStep {n : ℕ} |
| (x : (Universe n × Matrix n) × (ℕ × Option (ℕ × (Fin n → ℕ)))) := |
| (x.1,(x.2.1+1,match x.2.2 with |
| | some a => some a |
| | none => (scheduleMatrix x.1.2 (x.2.1+1)).map (fun t => (x.2.1+1,t)))) |
| |
| theorem bestMatrix_iterate {n : ℕ} (U : Universe n) (M : Matrix n) (k : ℕ) : |
| bestMatrixStep^[k] ((U,M),(0,none)) = ((U,M),(k,bestMatrix M k)) := by |
| induction k with |
| | zero => rfl |
| | succ k ih => rw [Function.iterate_succ_apply',ih]; rfl |
|
|
| def answerMatrix {n : ℕ} (M : Matrix n) : Option ℕ → Option (List ℕ) |
| | some T => (scheduleMatrix M T).map List.ofFn |
| | none => (bestMatrix M n).map (fun a => List.ofFn a.2) |
|
|
| theorem answerMatrix_closure {n : ℕ} (G : Instance n) (d : Option ℕ) : |
| encodeAnswer (answerMatrix (closureMatrix G n) d) = Algorithm.output G d := by |
| cases d <;> simp only [answerMatrix,Algorithm.output,scheduleMatrix_closure,bestMatrix_closure,slots] |
| all_goals rfl |
|
|
| namespace Uniform |
|
|
| def bestMatrixStep : Uniform (fun n => @ThreeMachine.StackCompiler.bestMatrixStep n) := by |
| let K := ((snd.comp fst).comp (Realizer.succ.uniform ℕ) : |
| Uniform (fun n (x : (Universe n × Matrix n) × (ℕ × Option (ℕ × (Fin n → ℕ)))) => x.2.1+1)) |
| let A := ((((fst.comp fst).pair (K.pair (fst.comp snd))).comp scheduleMatrix).pair K).comp |
| swap.optionMap |
| let R := ((((snd.comp snd).comp optionIsSome).pair id).comp ((snd.comp snd).choose A)) |
| exact (fst.pair (K.pair R)).congr (fun n x => by |
| simp only [Function.comp_apply,ThreeMachine.StackCompiler.bestMatrixStep] |
| cases x.2.2 <;> rfl) |
|
|
| def bestMatrix : Uniform (fun n (x : Universe n × Matrix n) => |
| ThreeMachine.StackCompiler.bestMatrix x.2 n) := |
| ((((fst.comp universeNumber).pair (id.pair (zero.pair none))).comp bestMatrixStep.iterate).comp |
| (snd.comp snd)).congr (fun n x => by |
| rcases x with ⟨U,M⟩ |
| simp only [Function.comp_apply,bestMatrix_iterate]) |
|
|
| def answerMatrix : Uniform (fun n (x : Universe n × (Matrix n × Option ℕ)) => |
| ThreeMachine.StackCompiler.answerMatrix x.2.1 x.2.2) := by |
| let T := ((((snd.comp snd).pair zero).comp getD) : |
| Uniform (fun n (x : Universe n × (Matrix n × Option ℕ)) => x.2.2.getD 0)) |
| let A : Uniform (fun n (x : Universe n × (Matrix n × Option ℕ)) => |
| (ThreeMachine.StackCompiler.scheduleMatrix x.2.1 (x.2.2.getD 0)).map List.ofFn) := |
| ((fst.pair (T.pair (snd.comp fst))).comp scheduleMatrix).comp functionList.mapOption |
| let B : Uniform (fun n (x : Universe n × (Matrix n × Option ℕ)) => |
| (ThreeMachine.StackCompiler.bestMatrix x.2.1 n).map (fun a => List.ofFn a.2)) := |
| ((fst.pair (snd.comp fst)).comp bestMatrix).comp (snd.comp functionList).mapOption |
| exact ((((snd.comp snd).comp optionIsSome).pair id).comp (A.choose B)).congr (fun n x => by |
| dsimp only [Function.comp_apply] |
| cases x.2.2 <;> rfl) |
|
|
| def unaryAnswer : Uniform (fun n (x : Universe n × (Instance n × Option ℕ)) => |
| ThreeMachine.StackCompiler.answerMatrix (closureMatrix x.2.1 n) x.2.2) := |
| (fst.pair ((((fst.pair (snd.comp fst)).comp reachMatrix).pair (snd.comp snd)))).comp answerMatrix |
|
|
| end Uniform |
| end ThreeMachine.StackCompiler |
|
|
| namespace ThreeMachine.Algorithm |
| open Structure |
|
|
| namespace Block |
|
|
| def Bounded {J : Type} (s : Block J) : Prop := ∀ x, s.time x ≤ s.length |
|
|
| theorem bounded_empty {J : Type} : (empty : Block J).Bounded := fun _ => le_rfl |
|
|
| theorem bounded_triple {J : Type} : (triple : Block J).Bounded := fun _ => le_rfl |
|
|
| theorem Bounded.append {J : Type} [DecidableEq J] {s t : Block J} |
| (hs : s.Bounded) (ht : t.Bounded) (W : Finset J) : (append W s t).Bounded := by |
| intro x |
| change (if x ∈ W then s.time x else s.length+t.time x) ≤ s.length+t.length |
| split_ifs |
| · exact (hs x).trans (Nat.le_add_right _ _) |
| · exact Nat.add_le_add_left (ht x) _ |
|
|
| theorem Valid.length_le {n : ℕ} {r : Fin n → Fin n → Prop} {W : Finset (Fin n)} |
| {s : Block (Fin n)} (hs : s.Valid r W) : s.length ≤ n := by |
| obtain ⟨b,hbl,_⟩ := hs |
| have h := b.size |
| rw [Set.ncard_coe_finset,hbl] at h |
| have hc := Finset.card_le_univ W |
| simp only [Fintype.card_fin] at hc |
| omega |
|
|
| end Block |
|
|
| namespace State |
| variable {J : Type} [DecidableEq J] |
|
|
| theorem bounded_advance (u : State J) {s t : Block J} (hs : s.Bounded) (ht : t.Bounded) : |
| (u.advance s t).Bounded := (hs.append Block.bounded_triple u.left).append ht u.upto |
|
|
| theorem bounded_finish (u : State J) {s t : Block J} (hs : s.Bounded) (ht : t.Bounded) : |
| (u.finish s t).Bounded := u.bounded_advance hs ht |
|
|
| end State |
|
|
| section Bounded |
| variable {J : Type} [Fintype J] [DecidableEq J] (r : J → J → Prop) [DecidableRel r] |
|
|
| def TableBounded (tab : List (Finset J × Block J)) : Prop := |
| ∀ W s, (W,s) ∈ tab → s.Bounded |
|
|
| def MarksBounded (marks : List (State J × Block J)) : Prop := |
| ∀ u s, (u,s) ∈ marks → s.Bounded |
|
|
| omit [Fintype J] in |
| theorem tryAdvance_bounded {tab : List (Finset J × Block J)} (htab : TableBounded tab) |
| (u : State J) (v : State J) {b s : Block J} (hb : b.Bounded) |
| (h : tryAdvance tab (u,b) v = some s) : s.Bounded := by |
| simp only [tryAdvance] at h |
| split_ifs at h |
| · cases hg : lookup tab (v.left \ u.upto) with |
| | none => simp [hg] at h |
| | some t => |
| have he : u.advance b t = s := Option.some.inj (by simpa [hg] using h) |
| exact he ▸ u.bounded_advance hb (htab _ _ (lookup_mem hg)) |
|
|
| omit [Fintype J] [DecidableRel r] in |
| theorem markings_bounded {tab : List (Finset J × Block J)} {sts : List (State J)} |
| (htab : TableBounded tab) (k : ℕ) : MarksBounded (markings tab sts k) := by |
| induction k with |
| | zero => |
| intro u s h |
| obtain ⟨_,hs⟩ := (mem_tableOf sts _ u s).mp h |
| exact htab _ _ (lookup_mem hs) |
| | succ k ih => |
| intro v s h |
| obtain ⟨_,hs⟩ := (mem_tableOf sts _ v s).mp h |
| cases he : lookup (markings tab sts k) v with |
| | some b => |
| have hb : b = s := Option.some.inj (by simpa only [he] using hs) |
| exact hb ▸ ih v b (lookup_mem he) |
| | none => |
| obtain ⟨⟨u,b⟩,hu,hh⟩ := firstResult_some (by simpa only [he] using hs) |
| exact tryAdvance_bounded htab u v (ih u b hu) hh |
|
|
| theorem solve_bounded {tab : List (Finset J × Block J)} (htab : TableBounded tab) |
| (family triples : List (Finset J)) {W : Finset J} {s : Block J} |
| (h : solve r tab family triples W = some s) : s.Bounded := by |
| simp only [solve] at h |
| split_ifs at h |
| · cases Option.some.inj h |
| exact Block.bounded_empty |
| · obtain ⟨⟨u,b⟩,hu,hs⟩ := firstResult_some h |
| have hg := markings_bounded htab (Fintype.card J) u b hu |
| cases ht : lookup tab u.right with |
| | none => simp [ht] at hs |
| | some t => |
| have he : u.finish b t = s := Option.some.inj (by simpa [ht] using hs) |
| exact he ▸ u.bounded_finish hg (htab _ _ (lookup_mem ht)) |
|
|
| theorem layers_bounded (family triples : List (Finset J)) (k : ℕ) : |
| TableBounded (layers r family triples k) := by |
| induction k with |
| | zero => |
| intro W s h |
| have he : (W,s) = (∅,Block.empty) := by simpa only [layers,List.mem_singleton] using h |
| cases he |
| exact Block.bounded_empty |
| | succ k ih => |
| intro W s h |
| exact solve_bounded r ih family triples ((mem_tableOf family _ W s).mp h).2 |
|
|
| end Bounded |
|
|
| end ThreeMachine.Algorithm |
|
|
| end |
|
|
| end OAI |
|
|
