lean/OAI/Probability/Ballisticity/Geometry/FiniteWordGeometry.lean

import Mathlib
import OAI.Probability.Ballisticity.Geometry.SignedHeight
import OAI.Probability.Ballisticity.Crossings.HitWord

namespace OAI

section

open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal BigOperators Topology Classical
namespace DirectionalTransience

lemma wordPath_append_prefix {d : ℕ} (x : Lattice d) (u v : List (Direction d))
    {n : ℕ} (hn : n ≤ u.length) : wordPath x (u ++ v) n = wordPath x u n := by
  induction u generalizing x n with
  | nil =>
    have : n = 0 := by simpa using hn
    simp [this]
  | cons e u ih =>
    cases n with
    | zero => simp
    | succ n =>
      simpa only [List.cons_append,wordPath] using ih (x+step e) (Nat.le_of_succ_le_succ hn)

lemma wordPath_append_suffix {d : ℕ} (x : Lattice d) (u v : List (Direction d))
    (n : ℕ) : wordPath x (u ++ v) (u.length+n) = wordPath (wordPath x u u.length) v n := by
  induction u generalizing x with
  | nil => simp [wordPath]
  | cons e u ih =>
    simpa only [List.cons_append,List.length_cons,Nat.succ_add,wordPath] using ih (x+step e)

lemma wordPath_after_end {d : ℕ} (x : Lattice d) (u : List (Direction d))
    {n : ℕ} (hn : u.length ≤ n) : wordPath x u n = wordPath x u u.length := by
  induction u generalizing x n with
  | nil => rfl
  | cons e u ih =>
    cases n with
    | zero => simp at hn
    | succ n =>
      simpa only [List.length_cons,wordPath] using ih (x+step e) (Nat.le_of_succ_le_succ hn)

lemma wordWeight_append {d : ℕ} (ω : Environment d) (x : Lattice d)
    (u v : List (Direction d)) :
    wordWeight ω x (u ++ v) = wordWeight ω x u * wordWeight ω (wordPath x u u.length) v := by
  induction u generalizing x with
  | nil => simp [wordWeight,wordPath]
  | cons e u ih => simp only [List.cons_append,wordWeight,List.length_cons,wordPath,ih,mul_assoc]

lemma wordPath_height_step {d : ℕ} (e : Direction d) (x : Lattice d)
    (w : List (Direction d)) (n : ℕ) :
    signedHeight e (wordPath x w (n+1)) ≤ signedHeight e (wordPath x w n)+1 := by
  rcases wordPath_step_or_stay x w n with h | ⟨g,h⟩
  · rw [h]; omega
  · rw [h]; exact signedHeight_step_le e _ g

lemma wordPath_hit_exact {d : ℕ} (e : Direction d) (x : Lattice d) (H : ℕ)
    (w : HitWord x (Strip (realPosition (step e)) x H) (Upper (realPosition (step e)) x H)) :
    signedHeight e (wordPath x w.val w.val.length) = signedHeight e x + H := by
  have htop : signedHeight e x + H ≤ signedHeight e (wordPath x w.val w.val.length) := by
    have h := w.property.1
    change dot (realPosition x) (realPosition (step e))+(H:ℝ) ≤
      dot (realPosition (wordPath x w.val w.val.length)) (realPosition (step e)) at h
    rw [signedHeight_projection,signedHeight_projection] at h
    exact_mod_cast h
  apply le_antisymm _ htop
  cases hlen : w.val.length with
  | zero => simpa only [hlen,wordPath_zero] using (show signedHeight e x ≤ signedHeight e x+H by omega)
  | succ n =>
    have h := (w.property.2 n (by omega)).2
    change dot (realPosition (wordPath x w.val n)) (realPosition (step e)) <
      dot (realPosition x) (realPosition (step e))+(H:ℝ) at h
    rw [signedHeight_projection,signedHeight_projection] at h
    have hn : signedHeight e (wordPath x w.val n) < signedHeight e x+H := by exact_mod_cast h
    have hs := wordPath_height_step e x w.val n
    omega

noncomputable def wordFirstHitTime {d : ℕ} (e : Direction d) (x : Lattice d)
    (s : ℕ) (w : List (Direction d)) : ℕ :=
  if h : ∃ n, signedHeight e x+s ≤ signedHeight e (wordPath x w n) then Nat.find h else 0

noncomputable def wordFirstHitPosition {d : ℕ} (e : Direction d) (x : Lattice d)
    (s : ℕ) (w : List (Direction d)) : Lattice d :=
  wordPath x w (wordFirstHitTime e x s w)

lemma wordFirstHitTime_spec {d : ℕ} (e : Direction d) (x : Lattice d)
    (s : ℕ) (w : List (Direction d))
    (h : ∃ n, signedHeight e x+s ≤ signedHeight e (wordPath x w n)) :
    signedHeight e x+s ≤ signedHeight e (wordFirstHitPosition e x s w) := by
  simp only [wordFirstHitPosition,wordFirstHitTime,dite_eq_left h]
  exact Nat.find_spec h

lemma wordFirstHitTime_le {d : ℕ} (e : Direction d) (x : Lattice d)
    (s : ℕ) (w : List (Direction d)) {n : ℕ}
    (h : signedHeight e x+s ≤ signedHeight e (wordPath x w n)) :
    wordFirstHitTime e x s w ≤ n := by
  simp only [wordFirstHitTime,dite_eq_left (show ∃ n, signedHeight e x+s ≤ signedHeight e (wordPath x w n) from ⟨n,h⟩)]
  exact Nat.find_min' _ h

lemma wordFirstHitTime_min {d : ℕ} (e : Direction d) (x : Lattice d)
    (s : ℕ) (w : List (Direction d)) {n : ℕ} (hn : n < wordFirstHitTime e x s w) :
    signedHeight e (wordPath x w n) < signedHeight e x+s := by
  by_contra h
  exact (wordFirstHitTime_le e x s w (le_of_not_gt h)).not_gt hn

lemma wordFirstHitTime_zero {d : ℕ} (e : Direction d) (x : Lattice d)
    (w : List (Direction d)) : wordFirstHitTime e x 0 w = 0 := by
  apply Nat.eq_zero_of_le_zero
  apply wordFirstHitTime_le
  simp

lemma wordFirstHitTime_endpoint {d : ℕ} (e : Direction d) (x : Lattice d) (H : ℕ)
    (w : HitWord x (Strip (realPosition (step e)) x H) (Upper (realPosition (step e)) x H)) :
    wordFirstHitTime e x H w.val = w.val.length := by
  have hh : signedHeight e x+(H:ℤ) ≤ signedHeight e (wordPath x w.val w.val.length) :=
    (wordPath_hit_exact e x H w).ge
  apply le_antisymm (wordFirstHitTime_le e x H w.val hh)
  by_contra h
  have hn : wordFirstHitTime e x H w.val < w.val.length := by omega
  have hp := (w.property.2 _ hn).2
  change dot (realPosition (wordFirstHitPosition e x H w.val)) (realPosition (step e)) <
    dot (realPosition x) (realPosition (step e))+(H:ℝ) at hp
  rw [signedHeight_projection,signedHeight_projection] at hp
  have hp' : signedHeight e (wordFirstHitPosition e x H w.val) < signedHeight e x+H := by exact_mod_cast hp
  exact hp'.not_ge (wordFirstHitTime_spec e x H w.val ⟨w.val.length,hh⟩)

lemma coordinate_mem_strip_iff {d : ℕ} (e : Direction d) (x y : Lattice d) (H : ℕ) :
    y ∈ Strip (realPosition (step e)) x H ↔
      signedHeight e x ≤ signedHeight e y ∧ signedHeight e y < signedHeight e x+H := by
  simp only [Strip,Set.mem_ofPred_eq,signedHeight_projection]
  constructor
  · rintro ⟨h1,h2⟩
    constructor
    · exact_mod_cast h1
    · exact_mod_cast h2
  · rintro ⟨h1,h2⟩
    constructor
    · exact_mod_cast h1
    · exact_mod_cast h2

lemma coordinate_mem_upper_iff {d : ℕ} (e : Direction d) (x y : Lattice d) (H : ℕ) :
    y ∈ Upper (realPosition (step e)) x H ↔ signedHeight e x+H ≤ signedHeight e y := by
  simp only [Upper,Set.mem_ofPred_eq,signedHeight_projection]
  constructor <;> intro h <;> exact_mod_cast h

lemma wordPath_hit_append {d : ℕ} (e : Direction d) (x : Lattice d) (h m : ℕ)
    (u : HitWord x (Strip (realPosition (step e)) x h) (Upper (realPosition (step e)) x h))
    (v : HitWord (wordPath x u.val u.val.length)
      (Strip (realPosition (step e)) (wordPath x u.val u.val.length) m)
      (Upper (realPosition (step e)) (wordPath x u.val u.val.length) m)) :
    wordPath x (u.val++v.val) ∈ HitAt (Strip (realPosition (step e)) x ((h+m : ℕ) : ℝ))
      (Upper (realPosition (step e)) x ((h+m : ℕ) : ℝ)) (u.val++v.val).length := by
  have hy := wordPath_hit_exact e x h u
  constructor
  · rw [List.length_append,wordPath_append_suffix,coordinate_mem_upper_iff,
      wordPath_hit_exact e _ m v,hy,Nat.cast_add]
    omega
  · intro n hn
    rw [coordinate_mem_strip_iff]
    by_cases hu : n < u.val.length
    · rw [wordPath_append_prefix x u.val v.val hu.le]
      have hp := (coordinate_mem_strip_iff e x (wordPath x u.val n) h).mp (u.property.2 n hu)
      constructor
      · exact hp.1
      · push_cast; omega
    · have he : n = u.val.length+(n-u.val.length) := by omega
      rw [he,wordPath_append_suffix]
      have hv : n-u.val.length < v.val.length := by simp only [List.length_append] at hn; omega
      have hp := (coordinate_mem_strip_iff e _ _ m).mp (v.property.2 _ hv)
      rw [hy] at hp
      constructor <;> push_cast <;> omega

lemma wordFirstHitTime_eq {d : ℕ} (e : Direction d) (x : Lattice d) (s : ℕ)
    (w : List (Direction d)) (n : ℕ)
    (hn : signedHeight e x+s ≤ signedHeight e (wordPath x w n))
    (hmin : ∀ i < n, signedHeight e (wordPath x w i) < signedHeight e x+s) :
    wordFirstHitTime e x s w = n := by
  apply le_antisymm (wordFirstHitTime_le e x s w hn)
  by_contra hc
  have hi : wordFirstHitTime e x s w < n := by omega
  exact (hmin _ hi).not_ge (wordFirstHitTime_spec e x s w ⟨n,hn⟩)

lemma wordFirstHitTime_append_prefix {d : ℕ} (e : Direction d) (x : Lattice d)
    (h s : ℕ) (hs : s ≤ h)
    (u : HitWord x (Strip (realPosition (step e)) x h) (Upper (realPosition (step e)) x h))
    (v : List (Direction d)) :
    wordFirstHitTime e x s (u.val++v) = wordFirstHitTime e x s u.val := by
  have hend : signedHeight e x+s ≤ signedHeight e (wordPath x u.val u.val.length) := by
    rw [wordPath_hit_exact e x h u]; omega
  have hn := wordFirstHitTime_le e x s u.val hend
  apply wordFirstHitTime_eq
  · rw [wordPath_append_prefix x u.val v hn]
    exact wordFirstHitTime_spec e x s u.val ⟨u.val.length,hend⟩
  · intro i hi
    rw [wordPath_append_prefix x u.val v (hi.le.trans hn)]
    exact wordFirstHitTime_min e x s u.val hi

lemma wordFirstHitPosition_append_prefix {d : ℕ} (e : Direction d) (x : Lattice d)
    (h s : ℕ) (hs : s ≤ h)
    (u : HitWord x (Strip (realPosition (step e)) x h) (Upper (realPosition (step e)) x h))
    (v : List (Direction d)) :
    wordFirstHitPosition e x s (u.val++v) = wordFirstHitPosition e x s u.val := by
  rw [wordFirstHitPosition,wordFirstHitTime_append_prefix e x h s hs u v]
  apply wordPath_append_prefix
  apply wordFirstHitTime_le
  rw [wordPath_hit_exact e x h u]
  omega

lemma wordFirstHitTime_append_suffix {d : ℕ} (e : Direction d) (x : Lattice d)
    (h m t : ℕ) (ht : t ≤ m)
    (u : HitWord x (Strip (realPosition (step e)) x h) (Upper (realPosition (step e)) x h))
    (v : HitWord (wordPath x u.val u.val.length)
      (Strip (realPosition (step e)) (wordPath x u.val u.val.length) m)
      (Upper (realPosition (step e)) (wordPath x u.val u.val.length) m)) :
    wordFirstHitTime e x (h+t) (u.val++v.val) =
      u.val.length+wordFirstHitTime e (wordPath x u.val u.val.length) t v.val := by
  have hy := wordPath_hit_exact e x h u
  have hend : signedHeight e (wordPath x u.val u.val.length)+t ≤
      signedHeight e (wordPath (wordPath x u.val u.val.length) v.val v.val.length) := by
    rw [wordPath_hit_exact e _ m v]; omega
  apply wordFirstHitTime_eq
  · rw [wordPath_append_suffix,Nat.cast_add,← add_assoc,← hy]
    exact wordFirstHitTime_spec e _ t v.val ⟨v.val.length,hend⟩
  · intro i hi
    by_cases hui : i < u.val.length
    · rw [wordPath_append_prefix x u.val v.val hui.le]
      have hp := ((coordinate_mem_strip_iff e x _ h).mp (u.property.2 _ hui)).2
      push_cast; omega
    · have he : i = u.val.length+(i-u.val.length) := by omega
      rw [he,wordPath_append_suffix,Nat.cast_add,← add_assoc,← hy]
      apply wordFirstHitTime_min
      omega

lemma wordFirstHitPosition_append_suffix {d : ℕ} (e : Direction d) (x : Lattice d)
    (h m t : ℕ) (ht : t ≤ m)
    (u : HitWord x (Strip (realPosition (step e)) x h) (Upper (realPosition (step e)) x h))
    (v : HitWord (wordPath x u.val u.val.length)
      (Strip (realPosition (step e)) (wordPath x u.val u.val.length) m)
      (Upper (realPosition (step e)) (wordPath x u.val u.val.length) m)) :
    wordFirstHitPosition e x (h+t) (u.val++v.val) =
      wordFirstHitPosition e (wordPath x u.val u.val.length) t v.val := by
  rw [wordFirstHitPosition,wordFirstHitTime_append_suffix e x h m t ht u v,
    wordPath_append_suffix]
  rfl

end DirectionalTransience

end

end OAI