openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /BalancedRules.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.Recorder | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.RadixEncoding | |
| namespace OAI | |
| /-! The balanced three-stack table in paper 379-09, `balanced.tex`. | |
| Every row preserves total prefix length, and its record identifies the | |
| individual work-step row. The table acts on arbitrary independent tails. -/ | |
| namespace ForcedComputation.Balanced | |
| open scoped BigOperators | |
| variable {Q A : Type*} | |
| inductive Record (Q A : Type*) | |
| | stay (q : Q) (a : A) | |
| | left (q : Q) (a c : A) | |
| | right (q : Q) (a c : A) | |
| | boundary (q : Q) (a : A) | |
| deriving DecidableEq, Fintype | |
| inductive Symbol (Q A : Type*) | |
| | work (a : A) | |
| | marked (a : A) | |
| | boundary | |
| | record (r : Record Q A) | |
| deriving DecidableEq, Fintype | |
| inductive Control (Q : Type*) | |
| | checkpoint (q : Q) | |
| | outward (q : Q) | |
| | inward (q : Q) | |
| | dispatch (q : Q) | |
| deriving DecidableEq, Fintype | |
| inductive Row (Q A : Type*) | |
| | enter (q : Q) (a : A) | |
| | outward (q : Q) (c : A) | |
| | supply (q : Q) | |
| | inward (q : Q) (c : A) | |
| | restore (q : Q) (a : A) | |
| | stay (q : Q) (a : A) | |
| | left (q : Q) (a c : A) | |
| | right (q : Q) (a c : A) | |
| | boundary (q : Q) (a : A) | |
| deriving DecidableEq, Fintype | |
| open ForcedComputation.Balanced.Symbol | |
| def Row.Allowed (M : Recorder.Machine Q A) : Row Q A → Prop | |
| | .enter q _ => M.halting q = false | |
| | .stay q a => M.move q a = 0 | |
| | .left q a _ => M.move q a = -1 | |
| | .right q a _ => M.move q a = 1 | |
| | .boundary q a => M.move q a = 1 | |
| | _ => True | |
| def Row.sourceControl : Row Q A → Control Q | |
| | .enter q _ => .checkpoint q | |
| | .outward q _ | .supply q => .outward q | |
| | .inward q _ | .restore q _ => .inward q | |
| | .stay q _ | .left q _ _ | .right q _ _ | .boundary q _ => .dispatch q | |
| def Row.targetControl (M : Recorder.Machine Q A) : Row Q A → Control Q | |
| | .enter q _ | .outward q _ => .outward q | |
| | .supply q | .inward q _ => .inward q | |
| | .restore q _ => .dispatch q | |
| | .stay q a | .left q a _ | .right q a _ | .boundary q a => .checkpoint (M.next q a) | |
| def Row.sourcePrefixes (blank : A) : Row Q A → Fin 3 → List (Symbol Q A) | |
| | .enter _ a => ![[], [work a], []] | |
| | .outward _ c => ![[], [work c], []] | |
| | .supply _ => ![[], [.boundary, work blank], []] | |
| | .inward _ c => ![[work c], [], []] | |
| | .restore _ a => ![[marked a], [], []] | |
| | .stay _ a => ![[], [work a], [work blank]] | |
| | .left _ a c => ![[work c], [work a], [work blank]] | |
| | .right _ a c => ![[], [work a, work c], [work blank]] | |
| | .boundary _ a => ![[], [work a, .boundary, work blank], [work blank]] | |
| def Row.targetPrefixes (M : Recorder.Machine Q A) (blank : A) : | |
| Row Q A → Fin 3 → List (Symbol Q A) | |
| | .enter _ a => ![[marked a], [], []] | |
| | .outward _ c => ![[work c], [], []] | |
| | .supply _ => ![[], [.boundary], [work blank]] | |
| | .inward _ c => ![[], [work c], []] | |
| | .restore _ a => ![[], [work a], []] | |
| | .stay q a => ![[], [work (M.write q a)], [record (.stay q a)]] | |
| | .left q a c => ![[], [work c, work (M.write q a)], [record (.left q a c)]] | |
| | .right q a c => ![[work (M.write q a)], [work c], [record (.right q a c)]] | |
| | .boundary q a => ![[work (M.write q a)], [work blank, .boundary], [record (.boundary q a)]] | |
| /-- Balance is an identity for the complete table, without assumptions on tails. -/ | |
| theorem Row.balanced (M : Recorder.Machine Q A) (blank : A) (r : Row Q A) : | |
| (∑ j : Fin 3, (r.sourcePrefixes blank j).length) = | |
| ∑ j : Fin 3, (r.targetPrefixes M blank j).length := by | |
| cases r <;> simp [Row.sourcePrefixes, Row.targetPrefixes, Fin.sum_univ_succ] | |
| abbrev Stack (Q A : Type*) := ℕ → Symbol Q A | |
| abbrev Tails (Q A : Type*) := Fin 3 → Stack Q A | |
| structure Configuration (Q A : Type*) where | |
| control : Control Q | |
| tapes : Tails Q A | |
| def prefixConfiguration (q : Control Q) (words : Fin 3 → List (Symbol Q A)) | |
| (tails : Tails Q A) : Configuration Q A := | |
| ⟨q, fun j => Radix.prependWord (words j) (tails j)⟩ | |
| def Row.source (blank : A) (r : Row Q A) (tails : Tails Q A) : Configuration Q A := | |
| prefixConfiguration r.sourceControl (r.sourcePrefixes blank) tails | |
| def Row.target (M : Recorder.Machine Q A) (blank : A) (r : Row Q A) | |
| (tails : Tails Q A) : Configuration Q A := | |
| prefixConfiguration (r.targetControl M) (r.targetPrefixes M blank) tails | |
| /-- A row replaces exactly its three specified prefixes and preserves every tail. -/ | |
| def Step (M : Recorder.Machine Q A) (blank : A) | |
| (x y : Configuration Q A) : Prop := | |
| ∃ r : Row Q A, r.Allowed M ∧ ∃ tails, x = r.source blank tails ∧ y = r.target M blank tails | |
| theorem Row.step {M : Recorder.Machine Q A} {blank : A} {r : Row Q A} | |
| (hr : r.Allowed M) (tails : Tails Q A) : | |
| Step M blank (r.source blank tails) (r.target M blank tails) := | |
| ⟨r, hr, tails, rfl, rfl⟩ | |
| /-- Finite words followed by an independent infinite tail decompose uniquely. -/ | |
| theorem prependWord_injective (w : List (Symbol Q A)) : | |
| Function.Injective (Radix.prependWord w) := by | |
| induction w with | |
| | nil => exact fun _ _ h => h | |
| | cons a w ih => | |
| intro u v h | |
| apply ih | |
| funext n | |
| exact congrFun h (n + 1) | |
| theorem Row.source_tails_injective (blank : A) (r : Row Q A) : | |
| Function.Injective (r.source blank) := by | |
| intro u v h | |
| funext j | |
| apply prependWord_injective (r.sourcePrefixes blank j) | |
| exact congrArg (fun c : Configuration Q A => c.tapes j) h | |
| theorem Row.target_tails_injective (M : Recorder.Machine Q A) (blank : A) (r : Row Q A) : | |
| Function.Injective (r.target M blank) := by | |
| intro u v h | |
| funext j | |
| apply prependWord_injective (r.targetPrefixes M blank j) | |
| exact congrArg (fun c : Configuration Q A => c.tapes j) h | |
| /-- Every target control specifies the stack whose top identifies the incoming row. -/ | |
| def targetKey (c : Configuration Q A) : Control Q × Symbol Q A := | |
| (c.control, match c.control with | |
| | .checkpoint _ => c.tapes 2 0 | |
| | .outward _ => c.tapes 0 0 | |
| | .inward _ => c.tapes 1 0 | |
| | .dispatch _ => c.tapes 1 0) | |
| def Row.targetKey (M : Recorder.Machine Q A) : Row Q A → Control Q × Symbol Q A | |
| | .enter q a => (.outward q, marked a) | |
| | .outward q c => (.outward q, work c) | |
| | .supply q => (.inward q, .boundary) | |
| | .inward q c => (.inward q, work c) | |
| | .restore q a => (.dispatch q, work a) | |
| | .stay q a => (.checkpoint (M.next q a), record (.stay q a)) | |
| | .left q a c => (.checkpoint (M.next q a), record (.left q a c)) | |
| | .right q a c => (.checkpoint (M.next q a), record (.right q a c)) | |
| | .boundary q a => (.checkpoint (M.next q a), record (.boundary q a)) | |
| theorem Row.targetKey_eq (M : Recorder.Machine Q A) (blank : A) | |
| (r : Row Q A) (tails : Tails Q A) : | |
| Balanced.targetKey (r.target M blank tails) = r.targetKey M := by | |
| cases r <;> simp [Balanced.targetKey, Row.target, prefixConfiguration, Row.targetControl, | |
| Row.targetPrefixes, Row.targetKey, Radix.prependWord, Radix.prepend] | |
| theorem Row.targetKey_injective (M : Recorder.Machine Q A) : | |
| Function.Injective (Row.targetKey M) := by | |
| intro r s h | |
| cases r <;> cases s <;> simp_all [Row.targetKey] | |
| /-- Incoming branches are disjoint for arbitrary independent stack tails. -/ | |
| theorem Row.target_rows_eq (M : Recorder.Machine Q A) (blank : A) | |
| {r s : Row Q A} {u v : Tails Q A} | |
| (h : r.target M blank u = s.target M blank v) : r = s := by | |
| apply Row.targetKey_injective M | |
| simpa only [Row.targetKey_eq] using congrArg Balanced.targetKey h | |
| /-- The complete target state recovers both the row and all three original tails. -/ | |
| theorem Row.target_unique (M : Recorder.Machine Q A) (blank : A) | |
| {r s : Row Q A} {u v : Tails Q A} | |
| (h : r.target M blank u = s.target M blank v) : r = s ∧ u = v := by | |
| have hrs := Row.target_rows_eq M blank h | |
| subst s | |
| exact ⟨rfl, r.target_tails_injective M blank h⟩ | |
| /-- A finite source decoder. It need not accept malformed configurations; | |
| on each guarded source cylinder it recovers the unique table row. -/ | |
| def decodeSource (M : Recorder.Machine Q A) (c : Configuration Q A) : Option (Row Q A) := | |
| match c.control with | |
| | .checkpoint q => match c.tapes 1 0 with | |
| | .work a => some (.enter q a) | |
| | _ => none | |
| | .outward q => match c.tapes 1 0 with | |
| | .work a => some (.outward q a) | |
| | .boundary => some (.supply q) | |
| | _ => none | |
| | .inward q => match c.tapes 0 0 with | |
| | .work a => some (.inward q a) | |
| | .marked a => some (.restore q a) | |
| | _ => none | |
| | .dispatch q => match c.tapes 1 0 with | |
| | .work a => | |
| if M.move q a = 0 then some (.stay q a) | |
| else if M.move q a = -1 then | |
| match c.tapes 0 0 with | |
| | .work b => some (.left q a b) | |
| | _ => none | |
| else match c.tapes 1 1 with | |
| | .work b => some (.right q a b) | |
| | .boundary => some (.boundary q a) | |
| | _ => none | |
| | _ => none | |
| theorem Row.decode_source {M : Recorder.Machine Q A} {blank : A} | |
| {r : Row Q A} (hr : r.Allowed M) (tails : Tails Q A) : | |
| decodeSource M (r.source blank tails) = some r := by | |
| cases r <;> simp_all [decodeSource, Row.source, prefixConfiguration, Row.sourceControl, | |
| Row.sourcePrefixes, Row.Allowed, Radix.prependWord, Radix.prepend] | |
| /-- Outgoing guarded branches are disjoint on the complete tail domains. -/ | |
| theorem Row.source_rows_eq {M : Recorder.Machine Q A} {blank : A} | |
| {r s : Row Q A} (hr : r.Allowed M) (hs : s.Allowed M) {u v : Tails Q A} | |
| (h : r.source blank u = s.source blank v) : r = s := by | |
| have hh := congrArg (decodeSource M) h | |
| rw [r.decode_source hr, s.decode_source hs] at hh | |
| exact Option.some.inj hh | |
| theorem Step.deterministic {M : Recorder.Machine Q A} {blank : A} | |
| {x y z : Configuration Q A} (hy : Step M blank x y) (hz : Step M blank x z) : y = z := by | |
| obtain ⟨r, hr, u, rfl, rfl⟩ := hy | |
| obtain ⟨s, hs, v, he, rfl⟩ := hz | |
| have hrs := Row.source_rows_eq hr hs he | |
| subst s | |
| have huv := r.source_tails_injective blank he | |
| rw [huv] | |
| theorem Step.predecessor_unique {M : Recorder.Machine Q A} {blank : A} | |
| {x y z : Configuration Q A} (hx : Step M blank x z) (hy : Step M blank y z) : x = y := by | |
| obtain ⟨r, hr, u, rfl, rfl⟩ := hx | |
| obtain ⟨s, hs, v, rfl, he⟩ := hy | |
| have huv := Row.target_unique M blank he | |
| rcases huv with ⟨hrs, huv⟩ | |
| subst s | |
| subst v | |
| rfl | |
| end ForcedComputation.Balanced | |
| end OAI | |