Blame for lean/OAI/Geometry/PeriodicTiling/Dependence.lean

import OAI.Geometry.PeriodicTiling.GraphTests
import OAI.Geometry.PeriodicTiling.CyclicCRT
import Mathlib.Algebra.Ring.Periodic
import Mathlib.Data.Finset.Piecewise
import Mathlib.Data.Fintype.Sigma
import Mathlib.Tactic.Ring

namespace OAI

universe uι uA uB

noncomputable section

namespace PeriodicTilingThree

section CoordinateReplacement

variable {ι : Type uι} [Fintype ι] [DecidableEq ι]
variable {A : ι → Type uA} {B : Type uB}

theorem eq_of_update_invariant (f : (∀ i, A i) → B)
    (hf : ∀ x i (a : A i), f (Function.update x i a) = f x)
    (x y : ∀ i, A i) : f x = f y := by
  have h : ∀ s : Finset ι, f (s.piecewise x y) = f y := by
    intro s
    induction s using Finset.induction_on with
    | empty => simp
    | insert i s hi ih => rw [Finset.piecewise_insert, hf, ih]
  simpa using h Finset.univ

theorem eq_of_update_invariant_off (f : (∀ i, A i) → B) (i : ι)
    (hf : ∀ j, j ≠ i → ∀ x (a : A j), f (Function.update x j a) = f x)
    (x y : ∀ i, A i) (hxy : x i = y i) : f x = f y := by
  have h : ∀ s : Finset ι, f (s.piecewise x y) = f y := by
    intro s
    induction s using Finset.induction_on with
    | empty => simp
    | insert j s hj ih =>
      rw [Finset.piecewise_insert]
      by_cases hji : j = i
      · subst j
        have hv : s.piecewise x y i = x i := by
          by_cases hi : i ∈ s <;> simp [Finset.piecewise, hi, hxy]
        rw [← hv, Function.update_eq_self]
        exact ih
      · exact (hf j hji _ _).trans ih
  simpa using h Finset.univ

end CoordinateReplacement

section Activity

variable {A : Type uA} {B : Type uB} [AddGroup A]

def DigitActive (g : A → B) (U : AddSubgroup A) : Prop :=
  ∃ w w', w - w' ∈ U ∧ g w ≠ g w'

theorem not_digitActive_iff (g : A → B) (U : AddSubgroup A) :
    ¬ DigitActive g U ↔ ∀ w w', w - w' ∈ U → g w = g w' := by
  simp only [DigitActive, not_exists, not_and, not_not]

end Activity

variable {p : ℕ} [NeZero p] (E : EncodingParameters p)

def seedResidue (p : ℕ) (x : Plane) : Residues p :=
  ((x.1 : ZMod (p ^ 2)), (x.2 : ZMod (p ^ 2)))

def seedRepresentative (p : ℕ) (s : Residues p) : Plane :=
  ((s.1.val : ℤ), (s.2.val : ℤ))

@[simp] theorem seedResidue_representative (s : Residues p) :
    seedResidue p (seedRepresentative p s) = s := by
  apply Prod.ext <;> simp [seedResidue, seedRepresentative]

def usefulAt (o : Outputs E) (i : Channel p) (x : Plane) (w : K E i) : P E i :=
  o.c (x, Function.update 0 i w) i

def ordinaryFactor (o : Outputs E) (n : Column p) (m : ℤ)
    (w : K E (.inl n)) : P E (.inl n) :=
  usefulAt E o (.inl n) (0, m) w

def seedFactor (o : Outputs E) (t : Fin 2) (s : Residues p)
    (w : K E (.inr t)) : P E (.inr t) :=
  usefulAt E o (.inr t) (seedRepresentative p s) w

def HasDependence (o : Outputs E) : Prop :=
  (∀ n x k, o.c (x, k) (.inl n) =
    ordinaryFactor E o n (lineValue n x) (k (.inl n))) ∧
  (∀ t x k, o.c (x, k) (.inr t) =
    seedFactor E o t (seedResidue p x) (k (.inr t)))

theorem ordinaryFactor_spec {o : Outputs E} (h : HasDependence E o)
    (n : Column p) (x : Plane) (k : Low E) :
    o.c (x, k) (.inl n) = ordinaryFactor E o n (lineValue n x) (k (.inl n)) :=
  h.1 n x k

theorem seedFactor_spec {o : Outputs E} (h : HasDependence E o)
    (t : Fin 2) (x : Plane) (k : Low E) :
    o.c (x, k) (.inr t) = seedFactor E o t (seedResidue p x) (k (.inr t)) :=
  h.2 t x k

theorem usefulAt_factor {o : Outputs E} (h : HasDependence E o)
    (x : Plane) (k : Low E) (i : Channel p) :
    o.c (x, k) i = usefulAt E o i x (k i) := by
  cases i with
  | inl n =>
    rw [h.1 n x k]
    symm
    simpa [usefulAt] using h.1 n x (Function.update 0 (.inl n) (k (.inl n)))
  | inr t =>
    rw [h.2 t x k]
    symm
    simpa [usefulAt] using h.2 t x (Function.update 0 (.inr t) (k (.inr t)))

theorem usefulAt_eq_of_lineValue_eq {o : Outputs E} (h : HasDependence E o)
    (n : Column p) {x y : Plane} (hxy : lineValue n x = lineValue n y)
    (w : K E (.inl n)) :
    usefulAt E o (.inl n) x w = usefulAt E o (.inl n) y w := by
  unfold usefulAt
  rw [h.1 n x _, h.1 n y _, hxy]

theorem usefulAt_eq_of_seedResidue_eq {o : Outputs E} (h : HasDependence E o)
    (t : Fin 2) {x y : Plane} (hxy : seedResidue p x = seedResidue p y)
    (w : K E (.inr t)) :
    usefulAt E o (.inr t) x w = usefulAt E o (.inr t) y w := by
  unfold usefulAt
  rw [h.2 t x _, h.2 t y _, hxy]

def Active (o : Outputs E) (i : Channel p) (x : Plane) (j : Label p i) : Prop :=
  DigitActive (usefulAt E o i x) (digitSubgroup E i j)

theorem digitActive_iff_coordinates (i : Channel p) (g : K E i → P E i)
    (j : Label p i) :
    DigitActive g (digitSubgroup E i j) ↔
      ∃ w w', (∀ q, q ≠ j → digitEquiv E i w q = digitEquiv E i w' q) ∧
        g w ≠ g w' := by
  simp only [DigitActive, sub_mem_digitSubgroup_iff]

theorem no_digitActive_iff_constant (i : Channel p) (g : K E i → P E i) :
    (∀ j, ¬ DigitActive g (digitSubgroup E i j)) ↔ ∃ c, ∀ w, g w = c := by
  constructor
  · intro h
    let e := digitEquiv E i
    have hu : ∀ z j (a : ZMod (E.digitPrime i j)),
        g (e.symm (Function.update z j a)) = g (e.symm z) := by
      intro z j a
      apply (not_digitActive_iff g (digitSubgroup E i j)).mp (h j)
      apply (sub_mem_digitSubgroup_iff E i j _ _).mpr
      intro q hq
      simp [e, hq]
    refine ⟨g 0, fun w => ?_⟩
    simpa [e] using eq_of_update_invariant (fun z => g (e.symm z)) hu (e w) (e 0)
  · rintro ⟨c, hc⟩ j
    apply (not_digitActive_iff g (digitSubgroup E i j)).mpr
    intro w w' _hww'
    exact (hc w).trans (hc w').symm

theorem no_active_iff_constant (o : Outputs E) (i : Channel p) (x : Plane) :
    (∀ j, ¬ Active E o i x j) ↔ ∃ c, ∀ w, usefulAt E o i x w = c :=
  no_digitActive_iff_constant E i (usefulAt E o i x)

theorem active_ordinary_iff {o : Outputs E} (h : HasDependence E o)
    (n : Column p) {x y : Plane} (hxy : lineValue n x = lineValue n y)
    (j : Label p (.inl n)) : Active E o (.inl n) x j ↔ Active E o (.inl n) y j := by
  have he : usefulAt E o (.inl n) x = usefulAt E o (.inl n) y :=
    funext (usefulAt_eq_of_lineValue_eq E h n hxy)
  unfold Active
  rw [he]

theorem active_seed_iff {o : Outputs E} (h : HasDependence E o)
    (t : Fin 2) {x y : Plane} (hxy : seedResidue p x = seedResidue p y)
    (j : Label p (.inr t)) : Active E o (.inr t) x j ↔ Active E o (.inr t) y j := by
  have he : usefulAt E o (.inr t) x = usefulAt E o (.inr t) y :=
    funext (usefulAt_eq_of_seedResidue_eq E h t hxy)
  unfold Active
  rw [he]

abbrev DependenceIndex (p : ℕ) :=
  (Σ i : Channel p, {j : Channel p // j ≠ i}) ⊕
    (Column p ⊕ (Fin 2 × Bool))

def lowGenerator (j : Channel p) : Base E :=
  (0, Function.update 0 j 1)

def seedStep (p : ℕ) (second : Bool) : Plane :=
  if second then (0, ((p ^ 2 : ℕ) : ℤ)) else (((p ^ 2 : ℕ) : ℤ), 0)

def dependenceChannel : DependenceIndex p → Channel p
  | .inl ⟨i, _⟩ => i
  | .inr (.inl n) => .inl n
  | .inr (.inr (t, _)) => .inr t

def dependenceShift : DependenceIndex p → Base E
  | .inl ⟨_, j⟩ => lowGenerator E j.1
  | .inr (.inl n) => (lineKernelStep n, 0)
  | .inr (.inr (_, axis)) => (seedStep p axis, 0)

def dependenceTile (d : DependenceIndex p) : Finset (G E) :=
  invarianceTile E (dependenceChannel d) (dependenceShift E d)

theorem dependenceTile_nonempty (d : DependenceIndex p) :
    (dependenceTile E d).Nonempty :=
  invarianceTile_nonempty E (dependenceChannel d) (dependenceShift E d)

theorem dependenceTile_card (d : DependenceIndex p) :
    (dependenceTile E d).card = (kernelTile E).card :=
  invarianceTile_card E (dependenceChannel d) (dependenceShift E d)

def dependenceTiles : Finset (Finset (G E)) := by
  classical
  exact Finset.univ.image (dependenceTile E)

def DependenceTests (o : Outputs E) : Prop :=
  ∀ d : DependenceIndex p, Tiles (dependenceTile E d) (graph o)

def DependenceInvariance (o : Outputs E) : Prop :=
  ∀ d : DependenceIndex p, ∀ b : Base E,
    o.c (b - dependenceShift E d) (dependenceChannel d) = o.c b (dependenceChannel d)

private theorem periodic_of_sub_eq {A : Type uA} {B : Type uB} [AddGroup A]
    (f : A → B) (v : A) (h : ∀ x, f (x - v) = f x) : Function.Periodic f v := by
  intro x
  simpa using (h (x + v)).symm

private theorem useful_update_of_generator (o : Outputs E) (i j : Channel p)
    (h : ∀ b, o.c (b - lowGenerator E j) i = o.c b i)
    (x : Plane) (k : Low E) (w : K E j) :
    o.c (x, Function.update k j w) i = o.c (x, k) i := by
  obtain ⟨a, ha⟩ := ZMod.intCast_surjective (k j - w)
  have he : (x, Function.update k j w) = (x, k) - a • lowGenerator E j := by
    apply Prod.ext
    · simp [lowGenerator]
    · funext l
      by_cases hlj : l = j
      · subst l
        simp [lowGenerator, zsmul_eq_mul, ha]
      · simp [lowGenerator, hlj]
  rw [he]
  exact (periodic_of_sub_eq (fun b => o.c b i) (lowGenerator E j) h).sub_zsmul_eq a

private theorem usefulAt_factor_of_generators (o : Outputs E)
    (h : ∀ i j, j ≠ i → ∀ b, o.c (b - lowGenerator E j) i = o.c b i)
    (x : Plane) (k : Low E) (i : Channel p) :
    o.c (x, k) i = usefulAt E o i x (k i) := by
  unfold usefulAt
  apply eq_of_update_invariant_off (fun k => o.c (x, k) i) i
  · intro j hji k' w
    exact useful_update_of_generator E o i j (h i j hji) x k' w
  · simp

@[simp] theorem seedResidue_sub_step
    {p : ℕ} [NeZero p]
    (x : Plane) (axis : Bool) :
    seedResidue p (x - seedStep p axis) = seedResidue p x := by
  have hp2 : (p : ZMod (p ^ 2)) ^ 2 = 0 := by
    rw [← Nat.cast_pow, ZMod.natCast_self]
  cases axis <;> apply Prod.ext <;> simp [seedResidue, seedStep, hp2]

theorem dependenceInvariance_iff (o : Outputs E) :
    DependenceInvariance E o ↔ HasDependence E o := by
  constructor
  · intro h
    have hlow : ∀ i j, j ≠ i → ∀ b, o.c (b - lowGenerator E j) i = o.c b i := by
      intro i j hji b
      exact h (.inl ⟨i, ⟨j, hji⟩⟩) b
    have hfactor := usefulAt_factor_of_generators E o hlow
    constructor
    · intro n x k
      have hstep : ∀ b : Base E,
          o.c (b - (lineKernelStep n, 0)) (.inl n) = o.c b (.inl n) :=
        h (.inr (.inl n))
      have hp := periodic_of_sub_eq (fun b : Base E => o.c b (.inl n))
        (lineKernelStep n, 0) hstep
      have he : (x, k) - x.1 • (lineKernelStep n, (0 : Low E)) =
          ((0, lineValue n x), k) := by
        apply Prod.ext
        · apply Prod.ext
          · simp [lineKernelStep]
          · simp [lineKernelStep, lineValue]
            ring
        · simp
      have hs := hp.sub_zsmul_eq (x := (x, k)) x.1
      rw [he] at hs
      exact hs.symm.trans (hfactor (0, lineValue n x) k (.inl n))
    · intro t x k
      have hfirst : ∀ b : Base E,
          o.c (b - (seedStep p false, 0)) (.inr t) = o.c b (.inr t) :=
        h (.inr (.inr (t, false)))
      have hsecond : ∀ b : Base E,
          o.c (b - (seedStep p true, 0)) (.inr t) = o.c b (.inr t) :=
        h (.inr (.inr (t, true)))
      have hp := periodic_of_sub_eq (fun b : Base E => o.c b (.inr t))
        (seedStep p false, 0) hfirst
      have hq := periodic_of_sub_eq (fun b : Base E => o.c b (.inr t))
        (seedStep p true, 0) hsecond
      obtain ⟨a, ha⟩ := (ZMod.intCast_eq_iff (p ^ 2) x.1 (seedResidue p x).1).mp rfl
      obtain ⟨b, hb⟩ := (ZMod.intCast_eq_iff (p ^ 2) x.2 (seedResidue p x).2).mp rfl
      have he : (x, k) - a • (seedStep p false, (0 : Low E)) -
          b • (seedStep p true, (0 : Low E)) =
          (seedRepresentative p (seedResidue p x), k) := by
        apply Prod.ext
        · apply Prod.ext
          · simpa [seedStep, seedRepresentative, zsmul_eq_mul,
              sub_eq_iff_eq_add, mul_comm] using ha
          · simpa [seedStep, seedRepresentative, zsmul_eq_mul,
              sub_eq_iff_eq_add, mul_comm] using hb
        · simp
      have hs := (hq.sub_zsmul_eq
        (x := (x, k) - a • (seedStep p false, (0 : Low E))) b).trans
          (hp.sub_zsmul_eq (x := (x, k)) a)
      rw [he] at hs
      exact hs.symm.trans (hfactor (seedRepresentative p (seedResidue p x)) k (.inr t))
  · intro h d xb
    rcases xb with ⟨x, k⟩
    rcases d with ⟨i, j⟩ | d
    · change o.c ((x, k) - (0, Function.update (0 : Low E) j.1 1)) i = o.c (x, k) i
      simp only [Prod.mk_sub_mk, sub_zero]
      rw [usefulAt_factor E h, usefulAt_factor E h]
      simp [Ne.symm j.property]
    · rcases d with n | ⟨t, axis⟩
      · change o.c ((x, k) - (lineKernelStep n, 0)) (.inl n) = o.c (x, k) (.inl n)
        simp only [Prod.mk_sub_mk, sub_zero]
        rw [h.1 n (x - lineKernelStep n) k, h.1 n x k]
        have he : lineValue n (x - lineKernelStep n) = lineValue n x := by
          simp [lineValue, lineKernelStep] ; ring
        rw [he]
      · change o.c ((x, k) - (seedStep p axis, 0)) (.inr t) = o.c (x, k) (.inr t)
        simp only [Prod.mk_sub_mk, sub_zero]
        rw [h.2 t (x - seedStep p axis) k, h.2 t x k, seedResidue_sub_step]

theorem dependenceTests_iff (o : Outputs E) :
    DependenceTests E o ↔ HasDependence E o := by
  have he : DependenceTests E o ↔ DependenceInvariance E o := by
    unfold DependenceTests DependenceInvariance dependenceTile
    simp only [invarianceTile_iff]
  exact he.trans (dependenceInvariance_iff E o)

theorem dependenceTiles_iff (o : Outputs E) :
    (∀ F ∈ dependenceTiles E, Tiles F (graph o)) ↔ HasDependence E o := by
  classical
  rw [← dependenceTests_iff E o]
  constructor
  · intro h d
    apply h (dependenceTile E d)
    exact Finset.mem_image.mpr ⟨d, Finset.mem_univ d, rfl⟩
  · intro h F hF
    obtain ⟨d, _hd, rfl⟩ := Finset.mem_image.mp hF
    exact h d

end PeriodicTilingThree

end

end OAI