openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /FiniteStackArithmetic.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.LatticeStacks | |
| namespace OAI | |
| /-! Faithfulness of finite little-endian integer stacks, including their | |
| infinite zero tails. This is used for the entire finite recorder table. -/ | |
| namespace ForcedComputation.Lattice | |
| theorem stackValue_injective_prefix {b d : ℕ} (hb : 0 < b) | |
| {a c : ℕ → ℕ} (ha : ∀ i < d, a i < b) (hc : ∀ i < d, c i < b) | |
| (he : stackValue b d a = stackValue b d c) : ∀ i < d, a i = c i := by | |
| induction d generalizing a c with | |
| | zero => intro i hi; omega | |
| | succ d ih => | |
| have hhead : a 0 = c 0 := by | |
| have h := congrArg (fun n => n % b) he | |
| simpa only [stackValue_head (ha 0 (by omega)), stackValue_head (hc 0 (by omega))] using h | |
| have htail : stackValue b d (fun i => a (i + 1)) = | |
| stackValue b d (fun i => c (i + 1)) := by | |
| have h := congrArg (fun n => n / b) he | |
| simpa only [stackValue_tail hb (ha 0 (by omega)), | |
| stackValue_tail hb (hc 0 (by omega))] using h | |
| intro i hi | |
| cases i with | |
| | zero => exact hhead | |
| | succ i => | |
| exact ih (fun j hj => ha (j + 1) (by omega)) | |
| (fun j hj => hc (j + 1) (by omega)) htail i (by omega) | |
| theorem stackValue_injective_zero_tail {b d : ℕ} (hb : 0 < b) | |
| {a c : ℕ → ℕ} (ha : ∀ i, a i < b) (hc : ∀ i, c i < b) | |
| (ha0 : ∀ i, d ≤ i → a i = 0) (hc0 : ∀ i, d ≤ i → c i = 0) | |
| (he : stackValue b d a = stackValue b d c) : a = c := by | |
| funext i | |
| by_cases hi : i < d | |
| · exact stackValue_injective_prefix hb (fun j _ => ha j) (fun j _ => hc j) he i hi | |
| · rw [ha0 i (by omega), hc0 i (by omega)] | |
| theorem prepend_injective {b a c L R : ℕ} (hb : 0 < b) (ha : a < b) (hc : c < b) | |
| (he : a + b * L = c + b * R) : a = c ∧ L = R := by | |
| have hm := congrArg (fun n => n % b) he | |
| have hd := congrArg (fun n => n / b) he | |
| constructor | |
| · simpa only [Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt ha, | |
| Nat.mod_eq_of_lt hc] using hm | |
| · simpa only [Nat.add_mul_div_left _ _ hb, Nat.div_eq_of_lt ha, | |
| Nat.div_eq_of_lt hc, Nat.zero_add] using hd | |
| theorem nat_eq_of_mod_div_eq {b L R : ℕ} (hm : L % b = R % b) (hd : L / b = R / b) : | |
| L = R := by | |
| calc | |
| L = L % b + b * (L / b) := (Nat.mod_add_div L b).symm | |
| _ = R % b + b * (R / b) := by rw [hm, hd] | |
| _ = R := Nat.mod_add_div R b | |
| /-- The written digit and both old stack tails are recoverable from the | |
| new stacks, once the incoming movement is known. -/ | |
| theorem nextStacks_recover {b L₁ L₂ R₁ R₂ a₁ a₂ : ℕ} | |
| (hb : 0 < b) (ha₁ : a₁ < b) (ha₂ : a₂ < b) (m : Fin 3) | |
| (hL : nextLeft b L₁ a₁ m = nextLeft b L₂ a₂ m) | |
| (hR : nextRight b L₁ R₁ a₁ m = nextRight b L₂ R₂ a₂ m) : | |
| L₁ = L₂ ∧ R₁ / b = R₂ / b ∧ a₁ = a₂ := by | |
| fin_cases m | |
| · simp only [nextLeft, nextRight] at hL hR | |
| obtain ⟨hm, ht⟩ := prepend_injective hb (Nat.mod_lt _ hb) (Nat.mod_lt _ hb) hR | |
| obtain ⟨ha, hq⟩ := prepend_injective hb ha₁ ha₂ ht | |
| exact ⟨nat_eq_of_mod_div_eq hm hL, hq, ha⟩ | |
| · simp only [nextLeft, nextRight] at hL hR | |
| obtain ⟨ha, hq⟩ := prepend_injective hb ha₁ ha₂ hR | |
| exact ⟨hL, hq, ha⟩ | |
| · simp only [nextLeft, nextRight] at hL hR | |
| obtain ⟨ha, hq⟩ := prepend_injective hb ha₁ ha₂ hL | |
| exact ⟨hq, hR, ha⟩ | |
| theorem nextStacks_injective_of_read {b L₁ L₂ R₁ R₂ a₁ a₂ : ℕ} | |
| (hb : 0 < b) (ha₁ : a₁ < b) (ha₂ : a₂ < b) (m : Fin 3) | |
| (hL : nextLeft b L₁ a₁ m = nextLeft b L₂ a₂ m) | |
| (hR : nextRight b L₁ R₁ a₁ m = nextRight b L₂ R₂ a₂ m) | |
| (hread : R₁ % b = R₂ % b) : L₁ = L₂ ∧ R₁ = R₂ ∧ a₁ = a₂ := by | |
| obtain ⟨hl, hr, ha⟩ := nextStacks_recover hb ha₁ ha₂ m hL hR | |
| exact ⟨hl, nat_eq_of_mod_div_eq hread hr, ha⟩ | |
| end ForcedComputation.Lattice | |
| end OAI | |