import Mathlib
import OAI.Analysis.HardSphere.Geometry.Vertex

namespace OAI

noncomputable section
open MeasureTheory Filter Set
open scoped ENNReal Topology BigOperators
open scoped BigOperators Classical
open scoped BigOperators Classical
namespace HardSphere.Lattice
abbrev DiscreteTorus (K : ℕ) := Fin 3 → ZMod K

def torusProjection (K : ℕ) (x : Vertex) : DiscreteTorus K := fun i ↦ (x i : ZMod K)

def rangeStep (a : ℕ) (x y : Vertex) : Prop := x≠y ∧ ∀ i, |x i-y i|≤a

def torusRangeStep (K a : ℕ) (x y : DiscreteTorus K) : Prop :=
  x≠y ∧ ∃ d : Vertex, (∀ i, |d i|≤a) ∧ ∀ i, y i=x i+(d i : ZMod K)

lemma rangeStep_symm {a : ℕ} {x y : Vertex} (h : rangeStep a x y) : rangeStep a y x :=
  ⟨h.1.symm,fun i ↦ by rw [abs_sub_comm]; exact h.2 i⟩

lemma torusRangeStep_symm {K a : ℕ} {x y : DiscreteTorus K} (h : torusRangeStep K a x y) :
    torusRangeStep K a y x := by
  obtain ⟨hne,d,hd,he⟩ := h
  refine ⟨hne.symm,-d,fun i ↦ by simpa using hd i,fun i ↦ ?_⟩
  simp only [Pi.neg_apply,Int.cast_neg,he i]
  abel

def forbiddenCuts {K : ℕ} (S : Finset (DiscreteTorus K)) (a : ℕ) (i : Fin 3) : Finset (ZMod K) :=
  S.biUnion fun x ↦ (Finset.Icc 1 a).image fun j : ℕ ↦ x i+(j : ZMod K)

lemma forbiddenCuts_card {K : ℕ} (S : Finset (DiscreteTorus K)) (a : ℕ) (i : Fin 3) :
    (forbiddenCuts S a i).card≤a*S.card := by
  calc
    _ ≤ ∑ x∈S, ((Finset.Icc 1 a).image fun j : ℕ ↦ x i+(j : ZMod K)).card := Finset.card_biUnion_le
    _ ≤ ∑ _x∈S, a := by
      apply Finset.sum_le_sum
      intro x _
      simpa only [Nat.card_Icc,Nat.add_sub_cancel] using
        (Finset.card_image_le (s := Finset.Icc 1 a) (f := fun j : ℕ ↦ x i+(j : ZMod K)))
    _ = a*S.card := by simp [Nat.mul_comm]

lemma exists_vacant_cut {K : ℕ} [NeZero K] (S : Finset (DiscreteTorus K)) (a : ℕ)
    (hsmall : a*S.card<K) (i : Fin 3) : ∃ c : ZMod K, c∉forbiddenCuts S a i := by
  by_contra hn
  push Not at hn
  have he : forbiddenCuts S a i=Finset.univ := Finset.eq_univ_of_forall hn
  have hc := forbiddenCuts_card S a i
  rw [he,Finset.card_univ,ZMod.card K] at hc
  omega

lemma cut_coordinate_bound {K : ℕ} [NeZero K] (S : Finset (DiscreteTorus K)) (a : ℕ)
    (i : Fin 3) {c : ZMod K} (hc : c∉forbiddenCuts S a i) {x : DiscreteTorus K} (hx : x∈S) :
    (x i-c).val+a<K := by
  have hv := ZMod.val_lt (x i-c)
  by_contra hn
  have hj₁ : 1≤K-(x i-c).val := by omega
  have hj₂ : K-(x i-c).val≤a := by omega
  apply hc
  apply Finset.mem_biUnion.mpr
  refine ⟨x,hx,Finset.mem_image.mpr ⟨K-(x i-c).val,Finset.mem_Icc.mpr ⟨hj₁,hj₂⟩,?_⟩⟩
  rw [Nat.cast_sub hv.le,ZMod.natCast_self,ZMod.natCast_zmod_val]
  abel

def cutLift {K : ℕ} (cut : DiscreteTorus K) (x : DiscreteTorus K) : Vertex :=
  fun i ↦ (cut i).val+(x i-cut i).val

lemma cutLift_projection {K : ℕ} [NeZero K] (cut x : DiscreteTorus K) :
    torusProjection K (cutLift cut x)=x := by
  ext i
  simp only [torusProjection,cutLift,Int.cast_add,Int.cast_natCast,ZMod.natCast_zmod_val]
  abel

lemma small_multiple_zero {K : ℕ} {z : ℤ} (hz : (z : ZMod K)=0) (hsmall : |z|<K) : z=0 := by
  apply Int.eq_zero_of_dvd_of_natAbs_lt_natAbs ((ZMod.intCast_zmod_eq_zero_iff_dvd z K).mp hz)
  rw [← Int.natCast_natAbs] at hsmall
  simpa only [Int.natAbs_natCast] using (show z.natAbs<K by exact_mod_cast hsmall)

lemma cutLift_edge {K : ℕ} [NeZero K] (S : Finset (DiscreteTorus K)) (a : ℕ)
    (cut : DiscreteTorus K) (hcut : ∀ i, cut i∉forbiddenCuts S a i)
    {x y : DiscreteTorus K} (hx : x∈S) (hy : y∈S) (hxy : torusRangeStep K a x y) :
    rangeStep a (cutLift cut x) (cutLift cut y) := by
  obtain ⟨hne,d,hd,he⟩ := hxy
  refine ⟨fun h ↦ hne (by simpa only [cutLift_projection] using congrArg (torusProjection K) h),?_⟩
  intro i
  have hx' := cut_coordinate_bound S a i (hcut i) hx
  have hy' := cut_coordinate_bound S a i (hcut i) hy
  have hd' := abs_le.mp (hd i)
  have hprojX := congrFun (cutLift_projection cut x) i
  have hprojY := congrFun (cutLift_projection cut y) i
  change ((cutLift cut x i : ℤ) : ZMod K)=x i at hprojX
  change ((cutLift cut y i : ℤ) : ZMod K)=y i at hprojY
  have hzero : ((cutLift cut y i-cutLift cut x i-d i : ℤ) : ZMod K)=0 := by
    push_cast
    rw [hprojX,hprojY,he i]
    abel
  have hsmall : |cutLift cut y i-cutLift cut x i-d i|<K := by
    dsimp only [cutLift]
    apply abs_lt.mpr
    constructor <;> omega
  have heq := small_multiple_zero hzero hsmall
  rw [show cutLift cut x i-cutLift cut y i= -d i by omega,abs_neg]
  exact hd i

theorem small_set_lift {K : ℕ} [NeZero K] (S : Finset (DiscreteTorus K)) (a : ℕ)
    (hsmall : a*S.card<K) :
    ∃ f : DiscreteTorus K → Vertex,
      (∀ x, torusProjection K (f x)=x) ∧
      (∀ x∈S, ∀ y∈S, torusRangeStep K a x y → rangeStep a (f x) (f y)) := by
  choose cut hcut using exists_vacant_cut S a hsmall
  exact ⟨cutLift cut,cutLift_projection cut,fun _ hx _ hy hxy ↦ cutLift_edge S a cut hcut hx hy hxy⟩

lemma connected_coordinate_span {V : Type*} [Fintype V] (G : SimpleGraph V)
    (hG : G.Preconnected) (f : V → Vertex) (a : ℕ)
    (hedge : ∀ x y, G.Adj x y → ∀ i, |f x i-f y i|≤a) (x y : V) (i : Fin 3) :
    |f x i-f y i|≤a*(Fintype.card V-1) := by
  obtain ⟨p⟩ := hG x y
  let q := p.toPath
  have hlen := q.isPath.length_lt
  have hwalk : ∀ {u v : V} (w : G.Walk u v), |f u i-f v i|≤(a:ℤ)*w.length := by
    intro u v w
    induction w with
    | nil => simp
    | @cons u v w huv p ih =>
      calc
        |f u i-f w i| ≤ |f u i-f v i|+|f v i-f w i| := abs_sub_le _ _ _
        _ ≤ (a:ℤ)+(a:ℤ)*p.length := add_le_add (hedge u v huv i) ih
        _ = (a:ℤ)*(SimpleGraph.Walk.cons huv p).length := by simp only [SimpleGraph.Walk.length_cons,Nat.cast_add,Nat.cast_one]; ring
  have hlen' : (q.val.length:ℤ)<Fintype.card V := by exact_mod_cast hlen
  exact (hwalk q.val).trans (mul_le_mul_of_nonneg_left (by omega) (by positivity))

def torusRangeGraph (K a : ℕ) : SimpleGraph (DiscreteTorus K) where
  Adj := torusRangeStep K a
  symm := ⟨by intro x y h; exact torusRangeStep_symm h⟩
  loopless := ⟨by intro x h; exact h.1 rfl⟩

def periodicLift (K a : ℕ) (S : Finset (DiscreteTorus K)) (r : Vertex) : Set Vertex :=
  {x | torusProjection K x∈S ∧ Relation.ReflTransGen
    (fun u v ↦ torusProjection K u∈S ∧ torusProjection K v∈S ∧ rangeStep a u v) r x}

lemma short_projection_ne {K a : ℕ} (hK : 2*a<K) {x y : Vertex} (h : rangeStep a x y) :
    torusProjection K x≠torusProjection K y := by
  intro he
  apply h.1
  ext i
  apply sub_eq_zero.mp
  apply small_multiple_zero
  · simp only [Int.cast_sub]
    exact sub_eq_zero.mpr (congrFun he i)
  · exact (h.2 i).trans_lt (by exact_mod_cast (show a<K by omega))

lemma rangeStep_projection {K a : ℕ} (hK : 2*a<K) {x y : Vertex} (h : rangeStep a x y) :
    torusRangeStep K a (torusProjection K x) (torusProjection K y) := by
  refine ⟨short_projection_ne hK h,y-x,fun i ↦ ?_,fun i ↦ ?_⟩
  · simp only [Pi.sub_apply,abs_sub_comm]; exact h.2 i
  · simp only [Pi.sub_apply,torusProjection,Int.cast_sub]; abel

lemma lift_offset_step {K a : ℕ} (hK : 2*a<K) (S : Finset (DiscreteTorus K))
    (f : DiscreteTorus K → Vertex) (hf : ∀ x, torusProjection K (f x)=x)
    (hedge : ∀ x∈S, ∀ y∈S, torusRangeStep K a x y → rangeStep a (f x) (f y))
    {x y : Vertex} (hx : torusProjection K x∈S) (hy : torusProjection K y∈S)
    (hxy : rangeStep a x y) : y-f (torusProjection K y)=x-f (torusProjection K x) := by
  have hxy' := hedge _ hx _ hy (rangeStep_projection hK hxy)
  ext i
  have hxproj := congrFun (hf (torusProjection K x)) i
  have hyproj := congrFun (hf (torusProjection K y)) i
  change ((f (torusProjection K x) i:ℤ):ZMod K)=(x i:ZMod K) at hxproj
  change ((f (torusProjection K y) i:ℤ):ZMod K)=(y i:ZMod K) at hyproj
  have hzero : ((y i-f (torusProjection K y) i-(x i-f (torusProjection K x) i):ℤ):ZMod K)=0 := by
    push_cast
    rw [hxproj,hyproj]
    simp
  have hbd := abs_le.mp (hxy.2 i)
  have hbd' := abs_le.mp (hxy'.2 i)
  have hK' : (2:ℤ)*a<K := by exact_mod_cast hK
  have heq := small_multiple_zero hzero (show |y i-f (torusProjection K y) i-(x i-f (torusProjection K x) i)|<K by
    apply abs_lt.mpr; constructor <;> omega)
  dsimp only [Pi.sub_apply]
  omega

lemma lift_offset_reach {K a : ℕ} (hK : 2*a<K) (S : Finset (DiscreteTorus K))
    (f : DiscreteTorus K → Vertex) (hf : ∀ x, torusProjection K (f x)=x)
    (hedge : ∀ x∈S, ∀ y∈S, torusRangeStep K a x y → rangeStep a (f x) (f y))
    {r x : Vertex} (hx : x∈periodicLift K a S r) :
    x-f (torusProjection K x)=r-f (torusProjection K r) := by
  rcases hx with ⟨hmem,hreach⟩
  clear hmem
  induction hreach with
  | refl => rfl
  | @tail u v _ huv ih => exact (lift_offset_step hK S f hf hedge huv.1 huv.2.1 huv.2.2).trans ih

lemma translated_projection {K : ℕ} (f : DiscreteTorus K → Vertex)
    (hf : ∀ x, torusProjection K (f x)=x) (r : Vertex) (x : DiscreteTorus K) :
    torusProjection K (f x+(r-f (torusProjection K r)))=x := by
  ext i
  have h₁ := congrFun (hf x) i
  have h₂ := congrFun (hf (torusProjection K r)) i
  change ((f x i:ℤ):ZMod K)=x i at h₁
  change ((f (torusProjection K r) i:ℤ):ZMod K)=(r i:ZMod K) at h₂
  simp only [torusProjection,Pi.add_apply,Pi.sub_apply,Int.cast_add,Int.cast_sub,h₁,h₂,
    sub_self,add_zero]

lemma rangeStep_translate {a : ℕ} {x y : Vertex} (h : rangeStep a x y) (t : Vertex) :
    rangeStep a (x+t) (y+t) := by
  refine ⟨fun he ↦ h.1 (add_right_cancel he),fun i ↦ ?_⟩
  simpa only [Pi.add_apply,add_sub_add_right_eq_sub] using h.2 i

lemma translated_reach {K a : ℕ} (S : Finset (DiscreteTorus K))
    (hS : ((torusRangeGraph K a).induce (↑S)).Preconnected)
    (f : DiscreteTorus K → Vertex) (hf : ∀ x, torusProjection K (f x)=x)
    (hedge : ∀ x∈S, ∀ y∈S, torusRangeStep K a x y → rangeStep a (f x) (f y))
    (r : Vertex) (hr : torusProjection K r∈S) (x : DiscreteTorus K) (hx : x∈S) :
    f x+(r-f (torusProjection K r))∈periodicLift K a S r := by
  refine ⟨by simpa only [translated_projection f hf] using hx,?_⟩
  have hp := (SimpleGraph.reachable_iff_reflTransGen _ _).mp
    (hS ⟨torusProjection K r,hr⟩ ⟨x,hx⟩)
  have hmap : ∀ {u v : ↑(↑S : Set (DiscreteTorus K))},
      Relation.ReflTransGen ((torusRangeGraph K a).induce (↑S)).Adj u v →
      Relation.ReflTransGen
        (fun u v ↦ torusProjection K u∈S ∧ torusProjection K v∈S ∧ rangeStep a u v)
        (f u.val+(r-f (torusProjection K r))) (f v.val+(r-f (torusProjection K r))) := by
    intro u v huv
    induction huv using Relation.ReflTransGen.trans_induction_on with
    | refl => exact .refl
    | @single u v huv =>
      apply Relation.ReflTransGen.single
      refine ⟨?_,?_,rangeStep_translate (hedge u.val u.property v.val v.property huv) _⟩
      · simpa only [translated_projection f hf,Finset.mem_coe] using u.property
      · simpa only [translated_projection f hf,Finset.mem_coe] using v.property
    | trans _ _ ih₁ ih₂ => exact ih₁.trans ih₂
  have h := hmap hp
  rw [show f (torusProjection K r)+(r-f (torusProjection K r))=r by abel] at h
  exact h

theorem small_periodic_lifts {K a : ℕ} [NeZero K] (hK : 2*a<K)
    (S : Finset (DiscreteTorus K)) (hsmall : a*S.card<K)
    (hS : ((torusRangeGraph K a).induce (↑S)).Preconnected)
    (r : Vertex) (hr : torusProjection K r∈S) :
    ∃ C : Finset Vertex,
      (↑C : Set Vertex)=periodicLift K a S r ∧
      Set.BijOn (torusProjection K) (↑C) (↑S) ∧
      (∀ x∈C, ∀ y∈C, ∀ i, |x i-y i|≤a*((S.card:ℤ)-1)) := by
  obtain ⟨f,hf,hedge⟩ := small_set_lift S a hsmall
  let g : DiscreteTorus K → Vertex := fun x ↦ f x+(r-f (torusProjection K r))
  let C : Finset Vertex := S.image g
  have hproj : ∀ x, torusProjection K (g x)=x := translated_projection f hf r
  have heq : (↑C : Set Vertex)=periodicLift K a S r := by
    ext x
    constructor
    · intro hx
      obtain ⟨u,hu,rfl⟩ := Finset.mem_image.mp hx
      exact translated_reach S hS f hf hedge r hr u hu
    · intro hx
      refine Finset.mem_image.mpr ⟨torusProjection K x,hx.1,?_⟩
      have he := lift_offset_reach hK S f hf hedge hx
      dsimp only [g]
      rw [← he]
      abel
  refine ⟨C,heq,?_,?_⟩
  · refine ⟨?_,?_,?_⟩
    · intro x hx
      rw [heq] at hx
      exact hx.1
    · intro x hx y hy hxy
      obtain ⟨u,hu,rfl⟩ := Finset.mem_image.mp hx
      obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hy
      rw [hproj,hproj] at hxy
      exact congrArg g hxy
    · intro x hx
      exact ⟨g x,Finset.mem_image.mpr ⟨x,hx,rfl⟩,hproj x⟩
  · intro x hx y hy i
    obtain ⟨u,hu,rfl⟩ := Finset.mem_image.mp hx
    obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hy
    have hspan := connected_coordinate_span ((torusRangeGraph K a).induce (↑S)) hS
      (fun x ↦ f x.val) a (fun x y h i ↦ (hedge x.val x.property y.val y.property h).2 i)
      ⟨u,hu⟩ ⟨v,hv⟩ i
    simpa only [g,Pi.add_apply,add_sub_add_right_eq_sub,Fintype.card_coe,Finset.coe_sort_coe] using hspan

end HardSphere.Lattice

end

end OAI