File size: 3,852 Bytes
37bcf52 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | 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
|