| import OAI.Computability.Scheduling.ListRoutines |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 |
|
|
| section |
|
|
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
|
|
| instance (n : ℕ) : Coding (Algorithm.State (Fin n)) := |
| ⟨fun s => enc (s.left,(s.middle,s.right))⟩ |
| instance (n : ℕ) : Coding (Algorithm.Block (Fin n)) := |
| ⟨fun s => enc (s.length,s.time)⟩ |
|
|
| abbrev Matrix (n : ℕ) := Fin n → Fin n → Bool |
|
|
| def matrixRel {n : ℕ} (M : Matrix n) (x y : Fin n) : Prop := M x y = true |
|
|
| instance {n : ℕ} (M : Matrix n) : DecidableRel (matrixRel M) := |
| fun _ _ => inferInstanceAs (Decidable (_ = true)) |
|
|
| namespace Uniform |
|
|
| def universeNumber : Uniform (fun n (_ : Universe n) => n) := |
| (universeList.comp length).congr (fun _ _ => List.length_finRange) |
|
|
| def stateParts : Uniform (fun n (s : Algorithm.State (Fin n)) => (s.left,(s.middle,s.right))) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def stateMake : Uniform (fun n (x : Finset (Fin n) × (Finset (Fin n) × Finset (Fin n))) => |
| (⟨x.1,x.2.1,x.2.2⟩ : Algorithm.State (Fin n))) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def stateLeft : Uniform (fun n (s : Algorithm.State (Fin n)) => s.left) := stateParts.comp fst |
|
|
| def stateMiddle : Uniform (fun n (s : Algorithm.State (Fin n)) => s.middle) := stateParts.comp (snd.comp fst) |
|
|
| def stateRight : Uniform (fun n (s : Algorithm.State (Fin n)) => s.right) := stateParts.comp (snd.comp snd) |
|
|
| def stateEq : Uniform (fun n (x : Algorithm.State (Fin n) × Algorithm.State (Fin n)) => |
| decide (x.1 = x.2)) := |
| (((((fst.comp stateLeft).pair (snd.comp stateLeft)).comp setEq).pair |
| (((((fst.comp stateMiddle).pair (snd.comp stateMiddle)).comp setEq).pair |
| (((fst.comp stateRight).pair (snd.comp stateRight)).comp setEq)).comp (Realizer.and.uniform ℕ))).comp |
| (Realizer.and.uniform ℕ)).congr (fun _ x => by |
| rcases x with ⟨⟨a,b,c⟩,⟨d,e,f⟩⟩ |
| apply Bool.eq_iff_iff.mpr |
| simp) |
|
|
| def blockParts : Uniform (fun n (s : Algorithm.Block (Fin n)) => (s.length,s.time)) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def blockMake : Uniform (fun n (x : ℕ × (Fin n → ℕ)) => (⟨x.1,x.2⟩ : Algorithm.Block (Fin n))) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def blockLength : Uniform (fun n (s : Algorithm.Block (Fin n)) => s.length) := blockParts.comp fst |
|
|
| def blockTime : Uniform (fun n (s : Algorithm.Block (Fin n)) => s.time) := blockParts.comp snd |
|
|
| def matrixGet : Uniform (fun n (x : Matrix n × (Fin n × Fin n)) => x.1 x.2.1 x.2.2) := |
| ((((fst.pair (snd.comp fst)).comp functionGet).pair (snd.comp snd)).comp functionGet) |
|
|
| def setAll {γ : ℕ → Type u1} [∀ n, Coding (γ n)] |
| {p : ∀ n, Fin n × γ n → Bool} (P : Uniform p) : |
| Uniform (fun n (x : Finset (Fin n) × γ n) => decide (∀ a ∈ x.1, p n (a,x.2) = true)) := |
| (setList.onFst.comp P.all).congr (fun _ x => by |
| apply Bool.eq_iff_iff.mpr |
| simp only [Function.comp_apply,List.all_eq_true,Finset.mem_sort,decide_eq_true_eq]) |
|
|
| def setAny {γ : ℕ → Type u2} [∀ n, Coding (γ n)] |
| {p : ∀ n, Fin n × γ n → Bool} (P : Uniform p) : |
| Uniform (fun n (x : Finset (Fin n) × γ n) => decide (∃ a ∈ x.1, p n (a,x.2) = true)) := |
| (setList.onFst.comp P.any).congr (fun _ x => by |
| apply Bool.eq_iff_iff.mpr |
| simp only [Function.comp_apply,List.any_eq_true,Finset.mem_sort,decide_eq_true_eq]) |
|
|
| variable {I : Type u3} {α : I → Type u4} [∀ i, Coding (α i)] |
|
|
| def andD {p q : ∀ i, α i → Prop} [∀ i, DecidablePred (p i)] [∀ i, DecidablePred (q i)] |
| (P : Uniform (fun i x => decide (p i x))) (Q : Uniform (fun i x => decide (q i x))) : |
| Uniform (fun i x => decide (p i x ∧ q i x)) := |
| ((P.pair Q).comp (Realizer.and.uniform I)).congr (fun _ _ => by simp) |
|
|
| def orD {p q : ∀ i, α i → Prop} [∀ i, DecidablePred (p i)] [∀ i, DecidablePred (q i)] |
| (P : Uniform (fun i x => decide (p i x))) (Q : Uniform (fun i x => decide (q i x))) : |
| Uniform (fun i x => decide (p i x ∨ q i x)) := |
| ((P.pair Q).comp (Realizer.or.uniform I)).congr (fun _ _ => by simp) |
|
|
| def notD {p : ∀ i, α i → Prop} [∀ i, DecidablePred (p i)] |
| (P : Uniform (fun i x => decide (p i x))) : |
| Uniform (fun i x => decide (¬p i x)) := |
| (P.comp (Realizer.not.uniform I)).congr (fun _ _ => by simp) |
|
|
| def noEdges : Uniform (fun n (x : Matrix n × (Finset (Fin n) × Finset (Fin n))) => |
| decide (∀ a ∈ x.2.1, ∀ b ∈ x.2.2, ¬matrixRel x.1 a b)) := by |
| let E : Uniform (fun n (x : Fin n × (Matrix n × Fin n)) => !x.2.1 x.2.2 x.1) := |
| (((snd.comp fst).pair ((snd.comp snd).pair fst)).comp matrixGet).comp (Realizer.not.uniform ℕ) |
| let F : Uniform (fun n (x : Fin n × (Matrix n × Finset (Fin n))) => |
| decide (∀ b ∈ x.2.2, ¬matrixRel x.2.1 x.1 b)) := |
| (((snd.comp snd).pair ((snd.comp fst).pair fst)).comp E.setAll).congr (fun _ _ => by |
| simp only [Function.comp_apply,Bool.not_eq_true,matrixRel,Bool.not_eq_true']) |
| exact (((snd.comp fst).pair (fst.pair (snd.comp snd))).comp F.setAll).congr (fun _ _ => by |
| simp only [Function.comp_apply,decide_eq_true_eq]) |
| |
| def stateCandidate : Uniform (fun n (x : Universe n × |
| (Finset (Fin n) × (Finset (Fin n) × Finset (Fin n)))) => |
| Algorithm.State.candidate x.2.1 x.2.2.1 x.2.2.2) := by |
| let L := (((snd.comp fst).pair (snd.comp (snd.comp fst))).comp setInter : |
| Uniform (fun n (x : Universe n × (Finset (Fin n) × (Finset (Fin n) × Finset (Fin n)))) => x.2.1 ∩ x.2.2.1)) |
| let Z := (snd.comp (snd.comp snd) : |
| Uniform (fun n (x : Universe n × (Finset (Fin n) × (Finset (Fin n) × Finset (Fin n)))) => x.2.2.2)) |
| exact (L.pair (Z.pair (((snd.comp fst).pair ((fst.pair (L.pair Z)).comp setUnion)).comp setDiff))).comp stateMake |
| |
| end Uniform |
| end ThreeMachine.StackCompiler |
| |
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
| namespace Uniform |
| |
| def stateUpto : Uniform (fun n (x : Universe n × Algorithm.State (Fin n)) => x.2.upto) := |
| (fst.pair ((snd.comp stateLeft).pair (snd.comp stateMiddle))).comp setUnion |
| |
| abbrev CompatInput (n : ℕ) := Universe n × (Matrix n × (Finset (Fin n) × Algorithm.State (Fin n))) |
| def scU : Uniform (fun n (x : CompatInput n) => x.1) := fst |
| def scM : Uniform (fun n (x : CompatInput n) => x.2.1) := snd.comp fst |
| def scW : Uniform (fun n (x : CompatInput n) => x.2.2.1) := snd.comp (snd.comp fst) |
| def scS : Uniform (fun n (x : CompatInput n) => x.2.2.2) := snd.comp (snd.comp snd) |
| def scL := scS.comp stateLeft |
| def scZ := scS.comp stateMiddle |
| def scR := scS.comp stateRight |
| def scLZ := (scU.pair (scL.pair scZ)).comp setUnion |
| def scLZR := (scU.pair (scLZ.pair scR)).comp setUnion |
| def scA := (scLZR.pair scW).comp setEq |
| def scB := (scL.pair scZ).comp setDisjoint |
| def scC := (scL.pair scR).comp setDisjoint |
| def scD := (scZ.pair scR).comp setDisjoint |
| def scE := ((scZ.comp setCard).pair (constant 3)).comp (Realizer.eqNat.uniform ℕ) |
| def scF := (scM.pair (scZ.pair scZ)).comp noEdges |
| def scH := (scM.pair (scZ.pair scL)).comp noEdges |
| def scI := (scM.pair (scR.pair scL)).comp noEdges |
| def scJ := (scM.pair (scR.pair scZ)).comp noEdges |
| def scIJ := scI.andD scJ |
| def scHIJ := scH.andD scIJ |
| def scFHIJ := scF.andD scHIJ |
| def scEFHIJ := scE.andD scFHIJ |
| def scDEFHIJ := scD.andD scEFHIJ |
| def scCDEFHIJ := scC.andD scDEFHIJ |
| def scBCDEFHIJ := scB.andD scCDEFHIJ |
| def scAll := scA.andD scBCDEFHIJ |
| def stateCompatible : Uniform (fun n (x : Universe n × |
| (Matrix n × (Finset (Fin n) × Algorithm.State (Fin n)))) => |
| decide (x.2.2.2.Compatible (matrixRel x.2.1) x.2.2.1)) := |
| scAll.congr (fun _ _ => by apply decide_eq_decide.mpr; rfl) |
| |
| def blockEmpty : Uniform (fun n (_ : Universe n) => (Algorithm.Block.empty : Algorithm.Block (Fin n))) := |
| (zero.pair ((id.pair unit).comp zero.vectorMap)).comp blockMake |
| |
| def blockTriple : Uniform (fun n (_ : Universe n) => (Algorithm.Block.triple : Algorithm.Block (Fin n))) := |
| ((constant 1).pair ((id.pair unit).comp (constant 1).vectorMap)).comp blockMake |
| |
| def blockAppend : Uniform (fun n (x : Universe n × |
| (Finset (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => |
| Algorithm.Block.append x.2.1 x.2.2.1 x.2.2.2) := by |
| let F : Uniform (fun n (x : Fin n × |
| (Finset (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => |
| if x.1 ∈ x.2.1 then x.2.2.1.time x.1 else x.2.2.1.length+x.2.2.2.time x.1) := by |
| let S := (snd.comp (snd.comp fst) : Uniform (fun n (x : Fin n × |
| (Finset (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => x.2.2.1)) |
| let T := (snd.comp (snd.comp snd) : Uniform (fun n (x : Fin n × |
| (Finset (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => x.2.2.2)) |
| exact (((fst.pair (snd.comp fst)).comp setMem).ite |
| (((S.comp blockTime).pair fst).comp functionGet) |
| (((S.comp blockLength).pair (((T.comp blockTime).pair fst).comp functionGet)).comp |
| (Realizer.add.uniform ℕ))).congr (fun _ _ => by simp) |
| exact ((((snd.comp (snd.comp fst)).comp blockLength).pair |
| ((snd.comp (snd.comp snd)).comp blockLength)).comp (Realizer.add.uniform ℕ)).pair |
| F.vectorMap |>.comp blockMake |
| |
| def stateAdvance : Uniform (fun n (x : Universe n × |
| (Algorithm.State (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => |
| x.2.1.advance x.2.2.1 x.2.2.2) := by |
| let U := (fst : Uniform (fun n (x : Universe n × |
| (Algorithm.State (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => x.1)) |
| let V := (snd.comp fst : Uniform (fun n (x : Universe n × |
| (Algorithm.State (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => x.2.1)) |
| let S := (snd.comp (snd.comp fst) : Uniform (fun n (x : Universe n × |
| (Algorithm.State (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => x.2.2.1)) |
| let T := (snd.comp (snd.comp snd) : Uniform (fun n (x : Universe n × |
| (Algorithm.State (Fin n) × (Algorithm.Block (Fin n) × Algorithm.Block (Fin n)))) => x.2.2.2)) |
| let B := (U.pair ((V.comp stateLeft).pair (S.pair (U.comp blockTriple)))).comp blockAppend |
| exact (U.pair (((U.pair V).comp stateUpto).pair (B.pair T))).comp blockAppend |
| |
| variable {I : Type u5} {α β γ : I → Type} |
| variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)] |
| |
| def lookupA [∀ i, DecidableEq (α i)] |
| (E : Uniform (fun i (x : α i × α i) => decide (x.1 = x.2))) : |
| Uniform (fun i (x : List (α i × β i) × α i) => Algorithm.lookup x.1 x.2) := |
| (lookup E).congr (fun _ x => by |
| induction x.1 with |
| | nil => rfl |
| | cons a xs ih => simp only [lookupList,Algorithm.lookup]; split <;> simp_all) |
| |
| def firstResultA {f : ∀ i, α i × γ i → Option (β i)} (R : Uniform f) : |
| Uniform (fun i (x : List (α i) × γ i) => Algorithm.firstResult (fun a => f i (a,x.2)) x.1) := |
| R.firstResult.congr (fun _ x => by |
| induction x.1 with |
| | nil => rfl |
| | cons a xs ih => simp only [List.filterMap_cons,Algorithm.firstResult]; cases f _ (a,x.2) <;> simp_all) |
| |
| def tableOfA {f : ∀ i, α i × γ i → Option (β i)} (R : Uniform f) : |
| Uniform (fun i (x : List (α i) × γ i) => Algorithm.tableOf x.1 (fun a => f i (a,x.2))) := |
| R.tableOf |
| |
| end Uniform |
| end ThreeMachine.StackCompiler |
| |
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
| abbrev Table (n : ℕ) := List (Finset (Fin n) × Algorithm.Block (Fin n)) |
| abbrev Marks (n : ℕ) := List (Algorithm.State (Fin n) × Algorithm.Block (Fin n)) |
| namespace Uniform |
| |
| variable {I : Type u6} {α : I → Type u7} {β : I → Type u8} |
| variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] |
| |
| def singleton : Uniform (fun i (a : α i) => [a]) := (id.pair nil).comp cons |
| |
| def product : Uniform (fun i (x : List (α i) × List (β i)) => x.1.product x.2) := |
| ((snd.pair fst).comp swap.map).flatMap.congr (fun _ _ => rfl) |
| |
| def states : Uniform (fun n (x : Universe n × (Matrix n × |
| (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n))))) => |
| Algorithm.states (matrixRel x.2.1) x.2.2.1 x.2.2.2.1 x.2.2.2.2) := by |
| let C : Uniform (fun n (x : (Finset (Fin n) × Finset (Fin n)) × |
| (Universe n × Finset (Fin n))) => Algorithm.State.candidate x.2.2 x.1.1 x.1.2) := |
| ((snd.comp fst).pair ((snd.comp snd).pair ((fst.comp fst).pair (fst.comp snd)))).comp stateCandidate |
| let F := (snd.comp (snd.comp fst) : Uniform (fun n (x : Universe n × (Matrix n × |
| (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n))))) => x.2.2.1)) |
| let Z := (snd.comp (snd.comp (snd.comp fst)) : Uniform (fun n (x : Universe n × (Matrix n × |
| (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n))))) => x.2.2.2.1)) |
| let W := (snd.comp (snd.comp (snd.comp snd)) : Uniform (fun n (x : Universe n × (Matrix n × |
| (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n))))) => x.2.2.2.2)) |
| let S := (((F.pair Z).comp product).pair (fst.pair W)).comp C.map |
| let P : Uniform (fun n (x : Algorithm.State (Fin n) × |
| (Universe n × (Matrix n × Finset (Fin n)))) => |
| decide (x.1.Compatible (matrixRel x.2.2.1) x.2.2.2)) := |
| ((snd.comp fst).pair ((snd.comp (snd.comp fst)).pair ((snd.comp (snd.comp snd)).pair fst))).comp stateCompatible |
| exact ((S.pair (fst.pair ((snd.comp fst).pair W))).comp P.filter).congr (fun _ x => by |
| simp only [Function.comp_apply,Algorithm.states,List.product,List.map_flatMap,List.map_map] |
| rfl) |
| |
| def advanceLast : Uniform (fun n (x : Algorithm.Block (Fin n) × |
| (Universe n × (Algorithm.State (Fin n) × Algorithm.Block (Fin n)))) => |
| x.2.2.1.advance x.2.2.2 x.1) := |
| ((snd.comp fst).pair ((snd.comp (snd.comp fst)).pair ((snd.comp (snd.comp snd)).pair fst))).comp stateAdvance |
| |
| def tryAdvance : Uniform (fun n (x : Universe n × |
| (Table n × ((Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × Algorithm.State (Fin n)))) => |
| Algorithm.tryAdvance x.2.1 x.2.2.1 x.2.2.2) := by |
| let U := (fst : Uniform (fun n (x : Universe n × |
| (Table n × ((Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × Algorithm.State (Fin n)))) => x.1)) |
| let T := (snd.comp fst : Uniform (fun n (x : Universe n × |
| (Table n × ((Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × Algorithm.State (Fin n)))) => x.2.1)) |
| let A := (snd.comp (snd.comp fst) : Uniform (fun n (x : Universe n × |
| (Table n × ((Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × Algorithm.State (Fin n)))) => x.2.2.1)) |
| let V := (snd.comp (snd.comp snd) : Uniform (fun n (x : Universe n × |
| (Table n × ((Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × Algorithm.State (Fin n)))) => x.2.2.2)) |
| let W := (U.pair (A.comp fst)).comp stateUpto |
| let L := V.comp stateLeft |
| let P := (W.pair L).comp setSubset |
| let O := (T.pair ((L.pair W).comp setDiff)).comp (lookupA setEq) |
| exact (P.ite ((O.pair (U.pair A)).comp advanceLast.optionMap) none).congr (fun _ _ => by |
| simp only [Function.comp_apply,Algorithm.tryAdvance,decide_eq_true_eq]) |
| |
| def expandBody : Uniform (fun n (x : Algorithm.State (Fin n) × |
| (Universe n × (Table n × Marks n))) => |
| match Algorithm.lookup x.2.2.2 x.1 with |
| | Option.some s => Option.some s |
| | Option.none => Algorithm.firstResult (fun u => Algorithm.tryAdvance x.2.2.1 u x.1) x.2.2.2) := by |
| let A : Uniform (fun n (x : (Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × |
| (Universe n × (Table n × Algorithm.State (Fin n)))) => |
| Algorithm.tryAdvance x.2.2.1 x.1 x.2.2.2) := |
| ((snd.comp fst).pair ((snd.comp (snd.comp fst)).pair (fst.pair (snd.comp (snd.comp snd))))).comp tryAdvance |
| let O := (((snd.comp (snd.comp snd)).pair fst).comp (lookupA stateEq) : |
| Uniform (fun n (x : Algorithm.State (Fin n) × (Universe n × (Table n × Marks n))) => |
| Algorithm.lookup x.2.2.2 x.1)) |
| let B := ((snd.comp (snd.comp snd)).pair |
| ((snd.comp fst).pair ((snd.comp (snd.comp fst)).pair fst))).comp A.firstResultA |
| exact ((O.pair B).comp optionOrElse).congr (fun _ x => by |
| simp only [Function.comp_apply]; cases Algorithm.lookup x.2.2.2 x.1 <;> rfl) |
| |
| def expand : Uniform (fun n (x : Universe n × |
| (Table n × (List (Algorithm.State (Fin n)) × Marks n))) => |
| Algorithm.expand x.2.1 x.2.2.1 x.2.2.2) := |
| ((snd.comp (snd.comp fst)).pair |
| (fst.pair ((snd.comp fst).pair (snd.comp (snd.comp snd))))).comp expandBody.tableOfA |>.congr |
| (fun _ x => by |
| simp only [Function.comp_apply,Algorithm.expand] |
| congr 1 |
| funext v |
| cases Algorithm.lookup x.2.2.2 v <;> rfl) |
| |
| def initialMarks : Uniform (fun n (x : Table n × List (Algorithm.State (Fin n))) => |
| Algorithm.tableOf x.2 (fun v => Algorithm.lookup x.1 v.left)) := |
| (swap.comp ((snd.pair (fst.comp stateLeft)).comp (lookupA setEq)).tableOfA) |
| |
| def markings : Uniform (fun n (x : ℕ × |
| (Universe n × (Table n × List (Algorithm.State (Fin n))))) => |
| Algorithm.markings x.2.2.1 x.2.2.2 x.1) := by |
| let F : Uniform (fun n (x : (Universe n × (Table n × List (Algorithm.State (Fin n)))) × Marks n) => |
| (x.1,Algorithm.expand x.1.2.1 x.1.2.2 x.2)) := |
| fst.pair ((((fst.comp fst).pair ((fst.comp (snd.comp fst)).pair |
| ((fst.comp (snd.comp snd)).pair snd)))).comp expand) |
| exact (((fst.pair (snd.pair (snd.comp (snd.comp initialMarks)))).comp F.iterate).comp snd).congr |
| (fun n x => by |
| dsimp only [Function.comp_apply] |
| have h : ∀ k, (fun p => (p.1,Algorithm.expand p.1.2.1 p.1.2.2 p.2))^[k] |
| (x.2,Algorithm.tableOf x.2.2.2 (fun v => Algorithm.lookup x.2.2.1 v.left)) = |
| (x.2,Algorithm.markings x.2.2.1 x.2.2.2 k) := by |
| intro k; induction k with |
| | zero => rfl |
| | succ k ih => rw [Function.iterate_succ_apply',ih]; rfl |
| rw [h]) |
|
|
| end Uniform |
| end ThreeMachine.StackCompiler |
|
|
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
| namespace Uniform |
|
|
| def finishing : Uniform (fun n (x : (Algorithm.State (Fin n) × Algorithm.Block (Fin n)) × |
| (Universe n × Table n)) => |
| (Algorithm.lookup x.2.2 x.1.1.right).map (x.1.1.finish x.1.2)) := |
| ((((snd.comp snd).pair ((fst.comp fst).comp stateRight)).comp (lookupA setEq)).pair |
| ((snd.comp fst).pair fst)).comp advanceLast.optionMap |
|
|
| def solve : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => |
| Algorithm.solve (matrixRel x.2.1) x.2.2.1 x.2.2.2.1 x.2.2.2.2.1 x.2.2.2.2.2) := by |
| let U := (fst : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => x.1)) |
| let M := (snd.comp fst : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => x.2.1)) |
| let T := (snd.comp (snd.comp fst) : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => x.2.2.1)) |
| let F := (snd.comp (snd.comp (snd.comp fst)) : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => x.2.2.2.1)) |
| let Z := (snd.comp (snd.comp (snd.comp (snd.comp fst))) : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => x.2.2.2.2.1)) |
| let W := (snd.comp (snd.comp (snd.comp (snd.comp snd))) : Uniform (fun n (x : Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n)))))) => x.2.2.2.2.2)) |
| let S := (U.pair (M.pair (F.pair (Z.pair W)))).comp states |
| let Marks := ((U.comp universeNumber).pair (U.pair (T.pair S))).comp markings |
| let Out := (Marks.pair (U.pair T)).comp finishing.firstResultA |
| exact ((W.comp setIsEmpty).ite (U.comp (blockEmpty.comp some)) Out).congr (fun _ _ => by |
| simp only [Function.comp_apply,Algorithm.solve,decide_eq_true_eq,Fintype.card_fin]) |
|
|
| def initialTable : Uniform (fun n (_ : Universe n) => ([(∅,Algorithm.Block.empty)] : Table n)) := |
| (setEmpty.pair blockEmpty).comp singleton |
|
|
| def layerStep : Uniform (fun n (x : (Universe n × (Matrix n × |
| (List (Finset (Fin n)) × List (Finset (Fin n))))) × Table n) => |
| (x.1,Algorithm.tableOf x.1.2.2.1 |
| (Algorithm.solve (matrixRel x.1.2.1) x.2 x.1.2.2.1 x.1.2.2.2))) := by |
| let B : Uniform (fun n (x : Finset (Fin n) × |
| ((Universe n × (Matrix n × (List (Finset (Fin n)) × List (Finset (Fin n))))) × Table n)) => |
| Algorithm.solve (matrixRel x.2.1.2.1) x.2.2 x.2.1.2.2.1 x.2.1.2.2.2 x.1) := |
| ((snd.comp (fst.comp fst)).pair ((snd.comp (fst.comp (snd.comp fst))).pair |
| ((snd.comp snd).pair ((snd.comp (fst.comp (snd.comp (snd.comp fst)))).pair |
| ((snd.comp (fst.comp (snd.comp (snd.comp snd)))).pair fst))))).comp solve |
| exact fst.pair (((fst.comp (snd.comp (snd.comp fst))).pair id).comp B.tableOfA) |
|
|
| def layers : Uniform (fun n (x : ℕ × (Universe n × (Matrix n × |
| (List (Finset (Fin n)) × List (Finset (Fin n)))))) => |
| Algorithm.layers (matrixRel x.2.2.1) x.2.2.2.1 x.2.2.2.2 x.1) := |
| (((fst.pair (snd.pair ((snd.comp fst).comp initialTable))).comp layerStep.iterate).comp snd).congr |
| (fun n x => by |
| dsimp only [Function.comp_apply] |
| have h : ∀ k, (fun p => (p.1,Algorithm.tableOf p.1.2.2.1 |
| (Algorithm.solve (matrixRel p.1.2.1) p.2 p.1.2.2.1 p.1.2.2.2)))^[k] |
| (x.2,[(∅,Algorithm.Block.empty)]) = |
| (x.2,Algorithm.layers (matrixRel x.2.2.1) x.2.2.2.1 x.2.2.2.2 k) := by |
| intro k; induction k with |
| | zero => rfl |
| | succ k ih => rw [Function.iterate_succ_apply',ih]; rfl |
| rw [h]) |
| |
| end Uniform |
| end ThreeMachine.StackCompiler |
| |
| end |
| |
| end OAI |
| |
