openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /BalancedCycle.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.BalancedRules | |
| namespace OAI | |
| /-! Finite sweeps in the balanced recorder. The preparatory cycle restores | |
| both work tapes and moves exactly one blank onto the history stack. -/ | |
| namespace ForcedComputation.Balanced | |
| variable {Q A : Type*} | |
| open ForcedComputation.Balanced.Symbol | |
| abbrev push := @Radix.prepend (Symbol Q A) | |
| abbrev word := @Radix.prependWord (Symbol Q A) | |
| def triple (q : Control Q) (l r h : Stack Q A) : Configuration Q A := | |
| ⟨q, ![l, r, h]⟩ | |
| theorem prefixConfiguration_three (q : Control Q) | |
| (a b c : List (Symbol Q A)) (l r h : Stack Q A) : | |
| prefixConfiguration q ![a, b, c] ![l, r, h] = | |
| triple q (word a l) (word b r) (word c h) := by | |
| change Configuration.mk q _ = Configuration.mk q _ | |
| apply congrArg (Configuration.mk q) | |
| funext j | |
| fin_cases j <;> rfl | |
| inductive Steps (M : Recorder.Machine Q A) (blank : A) : | |
| ℕ → Configuration Q A → Configuration Q A → Prop | |
| | refl (x) : Steps M blank 0 x x | |
| | next {n x y z} : Step M blank x y → Steps M blank n y z → Steps M blank (n + 1) x z | |
| theorem Step.steps {M : Recorder.Machine Q A} {blank : A} {x y : Configuration Q A} | |
| (h : Step M blank x y) : Steps M blank 1 x y := | |
| .next h (.refl y) | |
| theorem Steps.trans {M : Recorder.Machine Q A} {blank : A} | |
| {n m : ℕ} {x y z : Configuration Q A} | |
| (hxy : Steps M blank n x y) (hyz : Steps M blank m y z) : Steps M blank (n + m) x z := by | |
| induction hxy with | |
| | refl => simpa only [Nat.zero_add] using hyz | |
| | next hxy hrest ih => | |
| simpa only [Nat.add_assoc, Nat.add_comm 1 m] using Steps.next hxy (ih hyz) | |
| theorem enter_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (hq : M.halting q = false) (l r h : Stack Q A) : | |
| Step M blank (triple (.checkpoint q) l (push (work a) r) h) | |
| (triple (.outward q) (push (marked a) l) r h) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.enter q a).step hq ![l, r, h] | |
| theorem outward_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (c : A) | |
| (l r h : Stack Q A) : | |
| Step M blank (triple (.outward q) l (push (work c) r) h) | |
| (triple (.outward q) (push (work c) l) r h) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.outward q c).step (M := M) (blank := blank) trivial ![l, r, h] | |
| theorem supply_step (M : Recorder.Machine Q A) (blank : A) (q : Q) | |
| (l r h : Stack Q A) : | |
| Step M blank (triple (.outward q) l (push .boundary (push (work blank) r)) h) | |
| (triple (.inward q) l (push .boundary r) (push (work blank) h)) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.supply q).step (M := M) (blank := blank) trivial ![l, r, h] | |
| theorem inward_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (c : A) | |
| (l r h : Stack Q A) : | |
| Step M blank (triple (.inward q) (push (work c) l) r h) | |
| (triple (.inward q) l (push (work c) r) h) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.inward q c).step (M := M) (blank := blank) trivial ![l, r, h] | |
| theorem restore_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (l r h : Stack Q A) : | |
| Step M blank (triple (.inward q) (push (marked a) l) r h) | |
| (triple (.dispatch q) l (push (work a) r) h) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.restore q a).step (M := M) (blank := blank) trivial ![l, r, h] | |
| theorem word_append (a b : List (Symbol Q A)) (u : Stack Q A) : | |
| word (a ++ b) u = word a (word b u) := by | |
| induction a with | |
| | nil => rfl | |
| | cons c a ih => simp only [List.cons_append, Radix.prependWord, ih] | |
| abbrev workWord (w : List A) : List (Symbol Q A) := w.map work | |
| theorem outward_sweep (M : Recorder.Machine Q A) (blank : A) (q : Q) | |
| (w : List A) (l r h : Stack Q A) : | |
| Steps M blank w.length (triple (.outward q) l (word (workWord w) r) h) | |
| (triple (.outward q) (word (workWord w.reverse) l) r h) := by | |
| induction w generalizing l with | |
| | nil => exact .refl _ | |
| | cons c w ih => | |
| have hh := Steps.next (outward_step M blank q c l (word (workWord w) r) h) | |
| (ih (push (work c) l)) | |
| simpa only [List.length_cons, workWord, List.map_cons, List.reverse_cons, | |
| List.map_append, List.map_singleton, List.map_nil, word_append, Radix.prependWord] using hh | |
| theorem inward_sweep (M : Recorder.Machine Q A) (blank : A) (q : Q) | |
| (w : List A) (l r h : Stack Q A) : | |
| Steps M blank w.length (triple (.inward q) (word (workWord w) l) r h) | |
| (triple (.inward q) l (word (workWord w.reverse) r) h) := by | |
| induction w generalizing r with | |
| | nil => exact .refl _ | |
| | cons c w ih => | |
| have hh := Steps.next (inward_step M blank q c (word (workWord w) l) r h) | |
| (ih (push (work c) r)) | |
| simpa only [List.length_cons, workWord, List.map_cons, List.reverse_cons, | |
| List.map_append, List.map_singleton, List.map_nil, word_append, Radix.prependWord] using hh | |
| /-- On arbitrary independent tails, preparation removes one right-tail blank | |
| and adds that same blank to history, leaving the finite work window unchanged. -/ | |
| theorem preparation (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (hq : M.halting q = false) (w : List A) (l r h : Stack Q A) : | |
| Steps M blank (2 * w.length + 3) | |
| (triple (.checkpoint q) l | |
| (push (work a) (word (workWord w) (push .boundary (push (work blank) r)))) h) | |
| (triple (.dispatch q) l | |
| (push (work a) (word (workWord w) (push .boundary r))) (push (work blank) h)) := by | |
| have h₁ := (enter_step M blank q a hq l | |
| (word (workWord w) (push .boundary (push (work blank) r))) h).steps | |
| have h₂ := outward_sweep M blank q w (push (marked a) l) | |
| (push .boundary (push (work blank) r)) h | |
| have h₃ := (supply_step M blank q (word (workWord w.reverse) (push (marked a) l)) r h).steps | |
| have h₄ := inward_sweep M blank q w.reverse (push (marked a) l) | |
| (push .boundary r) (push (work blank) h) | |
| have h₅ := (restore_step M blank q a l (word (workWord w) (push .boundary r)) | |
| (push (work blank) h)).steps | |
| simp only [List.reverse_reverse, List.length_reverse] at h₄ | |
| have hh := (((h₁.trans h₂).trans h₃).trans h₄).trans h₅ | |
| convert hh using 1 | |
| omega | |
| theorem stay_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (hm : M.move q a = 0) (l r h : Stack Q A) : | |
| Step M blank (triple (.dispatch q) l (push (work a) r) (push (work blank) h)) | |
| (triple (.checkpoint (M.next q a)) l (push (work (M.write q a)) r) | |
| (push (record (.stay q a)) h)) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.stay q a).step hm ![l, r, h] | |
| theorem left_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (a c : A) | |
| (hm : M.move q a = -1) (l r h : Stack Q A) : | |
| Step M blank | |
| (triple (.dispatch q) (push (work c) l) (push (work a) r) (push (work blank) h)) | |
| (triple (.checkpoint (M.next q a)) l (push (work c) (push (work (M.write q a)) r)) | |
| (push (record (.left q a c)) h)) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.left q a c).step hm ![l, r, h] | |
| theorem right_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (a c : A) | |
| (hm : M.move q a = 1) (l r h : Stack Q A) : | |
| Step M blank | |
| (triple (.dispatch q) l (push (work a) (push (work c) r)) (push (work blank) h)) | |
| (triple (.checkpoint (M.next q a)) (push (work (M.write q a)) l) (push (work c) r) | |
| (push (record (.right q a c)) h)) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.right q a c).step hm ![l, r, h] | |
| theorem boundary_step (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (hm : M.move q a = 1) (l r h : Stack Q A) : | |
| Step M blank (triple (.dispatch q) l | |
| (push (work a) (push .boundary (push (work blank) r))) (push (work blank) h)) | |
| (triple (.checkpoint (M.next q a)) (push (work (M.write q a)) l) | |
| (push (work blank) (push .boundary r)) (push (record (.boundary q a)) h)) := by | |
| simpa only [Row.source, Row.target, Row.sourceControl, Row.targetControl, | |
| Row.sourcePrefixes, Row.targetPrefixes, prefixConfiguration_three, | |
| Radix.prependWord] using (Row.boundary q a).step hm ![l, r, h] | |
| theorem stay_cycle (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (hq : M.halting q = false) (hm : M.move q a = 0) (w : List A) (l r h : Stack Q A) : | |
| Steps M blank (2 * (w.length + 1) + 2) | |
| (triple (.checkpoint q) l | |
| (push (work a) (word (workWord w) (push .boundary (push (work blank) r)))) h) | |
| (triple (.checkpoint (M.next q a)) l | |
| (push (work (M.write q a)) (word (workWord w) (push .boundary r))) | |
| (push (record (.stay q a)) h)) := by | |
| have hp := preparation M blank q a hq w l r h | |
| have hh := hp.trans (stay_step M blank q a hm l (word (workWord w) (push .boundary r)) h).steps | |
| convert hh using 1 | |
| theorem left_cycle (M : Recorder.Machine Q A) (blank : A) (q : Q) (a c : A) | |
| (hq : M.halting q = false) (hm : M.move q a = -1) (w : List A) (l r h : Stack Q A) : | |
| Steps M blank (2 * (w.length + 1) + 2) | |
| (triple (.checkpoint q) (push (work c) l) | |
| (push (work a) (word (workWord w) (push .boundary (push (work blank) r)))) h) | |
| (triple (.checkpoint (M.next q a)) l | |
| (push (work c) (push (work (M.write q a)) (word (workWord w) (push .boundary r)))) | |
| (push (record (.left q a c)) h)) := by | |
| have hp := preparation M blank q a hq w (push (work c) l) r h | |
| have hh := hp.trans (left_step M blank q a c hm l (word (workWord w) (push .boundary r)) h).steps | |
| convert hh using 1 | |
| theorem right_cycle (M : Recorder.Machine Q A) (blank : A) (q : Q) (a c : A) | |
| (hq : M.halting q = false) (hm : M.move q a = 1) (w : List A) (l r h : Stack Q A) : | |
| Steps M blank (2 * (w.length + 2) + 2) | |
| (triple (.checkpoint q) l | |
| (push (work a) (push (work c) | |
| (word (workWord w) (push .boundary (push (work blank) r))))) h) | |
| (triple (.checkpoint (M.next q a)) (push (work (M.write q a)) l) | |
| (push (work c) (word (workWord w) (push .boundary r))) | |
| (push (record (.right q a c)) h)) := by | |
| have hp := preparation M blank q a hq (c :: w) l r h | |
| simp only [workWord, List.map_cons, Radix.prependWord] at hp | |
| have hh := hp.trans (right_step M blank q a c hm l | |
| (word (workWord w) (push .boundary r)) h).steps | |
| convert hh using 1 | |
| /-- A right move at the boundary creates a new blank work cell while retaining | |
| one boundary and the same infinite blank filler. -/ | |
| theorem boundary_cycle (M : Recorder.Machine Q A) (blank : A) (q : Q) (a : A) | |
| (hq : M.halting q = false) (hm : M.move q a = 1) (l h : Stack Q A) : | |
| Steps M blank 4 | |
| (triple (.checkpoint q) l | |
| (push (work a) (push .boundary (fun _ => work blank))) h) | |
| (triple (.checkpoint (M.next q a)) (push (work (M.write q a)) l) | |
| (push (work blank) (push .boundary (fun _ => work blank))) | |
| (push (record (.boundary q a)) h)) := by | |
| have hz : push (work blank) (fun _ : ℕ => work blank : Stack Q A) = | |
| (fun _ => work blank) := by | |
| funext n | |
| cases n <;> rfl | |
| have hp := preparation M blank q a hq [] l (fun _ => work blank) h | |
| simp only [workWord, List.map_nil, Radix.prependWord, List.length_nil, | |
| Nat.mul_zero, Nat.zero_add, hz] at hp | |
| have ht := boundary_step M blank q a hm l (fun _ => work blank) h | |
| rw [hz] at ht | |
| simpa only [Nat.reduceAdd] using hp.trans ht.steps | |
| end ForcedComputation.Balanced | |
| end OAI | |