lean/OAI/MathematicalPhysics/NavierStokes/Material/Encoding.lean

import OAI.MathematicalPhysics.NavierStokes.Material.Model

namespace OAI

namespace Alternating.Memory
open scoped BigOperators

noncomputable def fraction (b : ℕ) : List ℕ → ℝ
  | [] => 0
  | d :: ds => ((d : ℝ) + fraction b ds) / b

def AllowedDigits (b : ℕ) (ds : List ℕ) : Prop :=
  ∀ d ∈ ds, Even d ∧ d + 2 ≤ b

noncomputable def tailBound (b : ℕ) : ℝ := ((b : ℝ) - 2) / ((b : ℝ) - 1)

@[simp] theorem fraction_nil (b : ℕ) : fraction b [] = 0 := rfl

@[simp] theorem fraction_cons (b d : ℕ) (ds : List ℕ) :
    fraction b (d :: ds) = ((d : ℝ) + fraction b ds) / b := rfl

theorem fraction_nonneg (b : ℕ) (ds : List ℕ) : 0 ≤ fraction b ds := by
  induction ds with
  | nil => simp
  | cons d ds ih => simp only [fraction_cons]; positivity

theorem tailBound_nonneg {b : ℕ} (hb : 2 ≤ b) : 0 ≤ tailBound b := by
  have hb' : (2 : ℝ) ≤ b := by exact_mod_cast hb
  unfold tailBound
  exact div_nonneg (by linarith) (by linarith)

theorem tailBound_lt_one {b : ℕ} (hb : 2 ≤ b) : tailBound b < 1 := by
  have hb' : (2 : ℝ) ≤ b := by exact_mod_cast hb
  unfold tailBound
  exact (div_lt_one (by linarith)).2 (by linarith)

theorem fraction_le_tailBound {b : ℕ} (hb : 2 ≤ b) {ds : List ℕ}
    (hds : AllowedDigits b ds) : fraction b ds ≤ tailBound b := by
  have hb' : (2 : ℝ) ≤ b := by exact_mod_cast hb
  have hpos : (0 : ℝ) < b := by linarith
  have hkey : ((b : ℝ) - 1) * tailBound b = (b : ℝ) - 2 := by
    unfold tailBound
    field_simp [(by linarith : (b : ℝ) - 1 ≠ 0)]
  induction ds with
  | nil => simpa using tailBound_nonneg hb
  | cons d ds ih =>
    have hd : (d : ℝ) + 2 ≤ b := by
      exact_mod_cast (hds d (by simp)).2
    have hrest : AllowedDigits b ds := fun a ha => hds a (by simp [ha])
    rw [fraction_cons]
    apply (div_le_iff₀ hpos).2
    have := ih hrest
    nlinarith

theorem fraction_lt_one {b : ℕ} (hb : 2 ≤ b) {ds : List ℕ}
    (hds : AllowedDigits b ds) : fraction b ds < 1 :=
  (fraction_le_tailBound hb hds).trans_lt (tailBound_lt_one hb)

theorem fraction_mem_digit_interval {b d : ℕ} (hb : 2 ≤ b) {ds : List ℕ}
    (hds : AllowedDigits b ds) :
    fraction b (d :: ds) ∈ Set.Ico ((d : ℝ) / b) (((d : ℝ) + 1) / b) := by
  have hpos : (0 : ℝ) < b := by exact_mod_cast (by omega : 0 < b)
  rw [fraction_cons]
  exact ⟨div_le_div_of_nonneg_right (le_add_of_nonneg_right (fraction_nonneg b ds)) hpos.le,
    (div_lt_div_iff_of_pos_right hpos).2 (by have := fraction_lt_one hb hds; linarith)⟩

theorem fraction_append {b : ℕ} (_hb : 0 < b) (ds es : List ℕ) :
    fraction b (ds ++ es) = fraction b ds + (b : ℝ)⁻¹ ^ ds.length * fraction b es := by
  induction ds with
  | nil => simp
  | cons d ds ih =>
    simp only [List.cons_append, fraction_cons, List.length_cons, pow_succ, ih]
    ring

@[simp] theorem fraction_replicate_zero (b n : ℕ) :
    fraction b (List.replicate n 0) = 0 := by
  induction n with
  | zero => simp
  | succ n ih => simp [List.replicate_succ, ih]

def pad (K : ℕ) (ds : List ℕ) : List ℕ :=
  ds ++ List.replicate (K - ds.length) 0

theorem pad_length {ds : List ℕ} {K : ℕ} (h : ds.length ≤ K) :
    (pad K ds).length = K := by simp [pad, Nat.add_sub_of_le h]

theorem fraction_pad {b : ℕ} (hb : 0 < b) (K : ℕ) (ds : List ℕ) :
    fraction b (pad K ds) = fraction b ds := by simp [pad, fraction_append hb]

theorem allowedDigits_pad {b : ℕ} (hb : 2 ≤ b) {ds : List ℕ}
    (hds : AllowedDigits b ds) (K : ℕ) : AllowedDigits b (pad K ds) := by
  intro d hd
  simp only [pad, List.mem_append, List.mem_replicate] at hd
  rcases hd with hd | ⟨_, rfl⟩
  · exact hds d hd
  · exact ⟨by simp, by simpa using hb⟩

theorem fraction_denominator {b : ℕ} (hb : 0 < b) (ds : List ℕ) :
    ∃ k : ℤ, (b : ℝ) ^ ds.length * fraction b ds = k := by
  have hb0 : (b : ℝ) ≠ 0 := by exact_mod_cast (ne_of_gt hb)
  induction ds with
  | nil => exact ⟨0, by simp⟩
  | cons d ds ih =>
    rcases ih with ⟨k, hk⟩
    refine ⟨(b : ℤ) ^ ds.length * (d : ℤ) + k, ?_⟩
    simp only [List.length_cons, fraction_cons, pow_succ, Int.cast_add, Int.cast_mul,
      Int.cast_pow, Int.cast_natCast]
    rw [← hk]
    field_simp

theorem fraction_padded_denominator {b K : ℕ} (hb : 0 < b) (ds : List ℕ)
    (hK : ds.length ≤ K) : ∃ k : ℤ, (b : ℝ) ^ K * fraction b ds = k := by
  simpa [pad_length hK, fraction_pad hb] using fraction_denominator hb (pad K ds)

structure Block (b K : ℕ) where
  stateDigit : ℕ
  left : List ℕ
  right : List ℕ
  state_allowed : Even stateDigit ∧ stateDigit + 2 ≤ b
  left_allowed : AllowedDigits b left
  right_allowed : AllowedDigits b right
  left_length : left.length ≤ K
  right_length : right.length ≤ K

def Block.digits {b K : ℕ} (c : Block b K) : List ℕ :=
  c.stateDigit :: (pad K c.left ++ pad K c.right)

noncomputable def Block.code {b K : ℕ} (c : Block b K) : ℝ := fraction b c.digits
noncomputable def Block.leftCode {b K : ℕ} (c : Block b K) : ℝ := fraction b c.left
noncomputable def Block.rightCode {b K : ℕ} (c : Block b K) : ℝ := fraction b c.right

theorem Block.digits_length {b K : ℕ} (c : Block b K) : c.digits.length = 1 + 2 * K := by
  simp [Block.digits, pad_length c.left_length, pad_length c.right_length]
  omega

theorem Block.digits_allowed {b K : ℕ} (hb : 2 ≤ b) (c : Block b K) :
    AllowedDigits b c.digits := by
  intro d hd
  simp only [Block.digits, List.mem_cons, List.mem_append] at hd
  rcases hd with rfl | h | h
  · exact c.state_allowed
  · exact allowedDigits_pad hb c.left_allowed K d h
  · exact allowedDigits_pad hb c.right_allowed K d h

theorem Block.code_formula {b K : ℕ} (hb : 0 < b) (c : Block b K) :
    c.code = ((c.stateDigit : ℝ) + c.leftCode + (b : ℝ)⁻¹ ^ K * c.rightCode) / b := by
  simp [Block.code, Block.digits, fraction_append hb, pad_length c.left_length,
    fraction_pad hb, Block.leftCode, Block.rightCode, add_assoc]

theorem Block.code_nonneg {b K : ℕ} (c : Block b K) : 0 ≤ c.code :=
  fraction_nonneg _ _

theorem Block.code_le {b K : ℕ} (hb : 2 ≤ b) (c : Block b K) : c.code ≤ tailBound b :=
  fraction_le_tailBound hb (c.digits_allowed hb)

theorem Block.code_denominator {b K : ℕ} (hb : 0 < b) (c : Block b K) :
    ∃ k : ℤ, (b : ℝ) ^ (1 + 2 * K) * c.code = k := by
  simpa [c.digits_length, Block.code] using fraction_denominator hb c.digits

theorem Block.left_denominator {b K : ℕ} (hb : 0 < b) (c : Block b K) :
    ∃ k : ℤ, (b : ℝ) ^ K * c.leftCode = k :=
  fraction_padded_denominator hb c.left c.left_length

theorem Block.right_denominator {b K : ℕ} (hb : 0 < b) (c : Block b K) :
    ∃ k : ℤ, (b : ℝ) ^ K * c.rightCode = k :=
  fraction_padded_denominator hb c.right c.right_length

theorem Block.tail_mem {b K : ℕ} (hb : 2 ≤ b) (c : Block b K) :
    c.leftCode + (b : ℝ)⁻¹ ^ K * c.rightCode ∈ Set.Icc 0 (tailBound b) := by
  have hbpos : 0 < b := by omega
  have hcode : fraction b (pad K c.left ++ pad K c.right) =
      c.leftCode + (b : ℝ)⁻¹ ^ K * c.rightCode := by
    simp [fraction_append hbpos, fraction_pad hbpos, pad_length c.left_length,
      Block.leftCode, Block.rightCode]
  rw [← hcode]
  refine ⟨fraction_nonneg _ _, fraction_le_tailBound hb ?_⟩
  intro d hd
  rcases List.mem_append.1 hd with h | h
  · exact allowedDigits_pad hb c.left_allowed K d h
  · exact allowedDigits_pad hb c.right_allowed K d h

theorem Block.right_mem {b K : ℕ} (hb : 2 ≤ b) (c : Block b K) :
    c.rightCode ∈ Set.Icc 0 (tailBound b) :=
  ⟨fraction_nonneg _ _, fraction_le_tailBound hb c.right_allowed⟩

end Alternating.Memory

end OAI