import Mathlib
import OAI.Probability.CriticalPercolation.Growth.HomogeneousGeometry
import OAI.Probability.CriticalPercolation.Harmonic.FiniteHilbert
import OAI.Probability.CriticalPercolation.Harmonic.GraphWalkOperator

namespace OAI

section
noncomputable section
open Set Function
open scoped Classical BigOperators

namespace CriticalPercolation.HomogeneousAnalysis.Geometry
open HarmonicAnalysis

variable {X : Type*} (W : Geometry X)

lemma degree_pos [Infinite X] : 0<W.degree := by
  obtain ⟨x,hx⟩ := exists_ne W.root
  obtain ⟨p⟩ := W.connected W.root x
  cases p with
  | nil => exact (hx rfl).elim
  | @cons a y z h p => exact Finset.card_pos.mpr ⟨y,W.mem_neighbors.mpr h⟩

lemma averaging_mass (hD : 0<W.degree) (f : FH X) : FH.mass (W.averaging f)=FH.mass f := by
  have hc : (W.degree:ℝ)≠0 := by exact_mod_cast hD.ne'
  have hdelta (x : X) : FH.mass (W.averaging (FH.delta x))=1 := by
    rw [W.averaging_delta,map_smul,map_sum]
    simp only [FH.mass_delta,Finset.sum_const,nsmul_eq_mul,mul_one,smul_eq_mul,W.neighbors_card]
    exact inv_mul_cancel₀ hc
  rw [←f.delta_decomposition]
  simp only [map_sum,map_smul,hdelta,FH.mass_delta]
lemma lazyWalk_nonnegative (f : FH X) (hf : ∀ x, 0≤f x) : ∀ x, 0≤W.lazyWalk f x := by
  intro x
  rw [W.lazyWalk_coordinate]
  exact mul_nonneg (by norm_num) (add_nonneg (hf x)
    (mul_nonneg (by positivity) (Finset.sum_nonneg (fun y hy => hf y))))
lemma lazyWalk_mass (hD : 0<W.degree) (f : FH X) : FH.mass (W.lazyWalk f)=FH.mass f := by
  rw [W.lazyWalk_apply,map_smul,map_add,W.averaging_mass hD]
  simp only [smul_eq_mul]; ring

def walkFeature (n : ℕ) (x : X) : FH X := (W.lazyWalk^n) (FH.delta x)
abbrev walkState (n : ℕ) := W.walkFeature n W.root
@[simp] lemma walkFeature_zero (x : X) : W.walkFeature 0 x=FH.delta x := rfl
lemma walkFeature_succ (n : ℕ) (x : X) : W.walkFeature (n+1) x=W.lazyWalk (W.walkFeature n x) := by
  simp only [walkFeature,pow_succ',Module.End.mul_apply]
lemma walkState_succ (n : ℕ) : W.walkState (n+1)=W.lazyWalk (W.walkState n) := W.walkFeature_succ n W.root
lemma walkState_nonnegative (n : ℕ) : ∀ x, 0≤W.walkState n x := by
  induction n with
  | zero => intro x; simp only [walkState,walkFeature_zero,FH.delta_apply]; split <;> norm_num
  | succ n ih => rw [W.walkState_succ]; exact W.lazyWalk_nonnegative _ ih
lemma walkState_mass (hD : 0<W.degree) (n : ℕ) : FH.mass (W.walkState n)=1 := by
  induction n with
  | zero => exact FH.mass_delta _
  | succ n ih => rw [W.walkState_succ,W.lazyWalk_mass hD,ih]
lemma walkState_root_pos (n : ℕ) : 0<W.walkState n W.root := by
  induction n with
  | zero => simp
  | succ n ih =>
    rw [W.walkState_succ,W.lazyWalk_coordinate]
    have hs : 0≤(W.degree:ℝ)⁻¹*∑ y∈W.neighbors W.root, W.walkState n y := by
      exact mul_nonneg (by positivity) (Finset.sum_nonneg (fun y hy => W.walkState_nonnegative n y))
    positivity
lemma walkState_support (n : ℕ) {x : X} (hx : x∉W.ball n) : W.walkState n x=0 := by
  induction n generalizing x with
  | zero =>
    have hne : x≠W.root := by intro h; apply hx; rw [h]; exact W.self_mem_around _ _
    simp [hne]
  | succ n ih =>
    rw [W.walkState_succ,W.lazyWalk_coordinate,ih (fun h => hx (W.ball_mono (by omega) h))]
    have hs : (∑ y∈W.neighbors x, W.walkState n y)=0 := by
      apply Finset.sum_eq_zero
      intro y hy
      apply ih
      intro hn
      apply hx
      apply W.mem_around_add hn
      exact W.mem_around.mpr ⟨SimpleGraph.Walk.cons (W.mem_neighbors.mp hy).symm .nil,by simp⟩
    rw [hs]; ring
lemma walkPower_symmetric (n : ℕ) (f g : FH X) :
    inner ℝ ((W.lazyWalk^n) f) g=inner ℝ f ((W.lazyWalk^n) g) := by
  induction n generalizing f g with
  | zero => rfl
  | succ n ih =>
    calc
      _ = inner ℝ ((W.lazyWalk^n) (W.lazyWalk f)) g := by rw [pow_succ,Module.End.mul_apply]
      _ = inner ℝ (W.lazyWalk f) ((W.lazyWalk^n) g) := ih _ _
      _ = inner ℝ f (W.lazyWalk ((W.lazyWalk^n) g)) := W.lazyWalk_symmetric _ _
      _ = _ := by rw [pow_succ',Module.End.mul_apply]
lemma walkState_double_at_root (n : ℕ) : W.walkState (2*n) W.root=‖W.walkState n‖^2 := by
  have hh := W.walkPower_symmetric n (FH.delta W.root) (W.walkState n)
  rw [FH.delta_inner] at hh
  have he : (W.lazyWalk^n) (W.walkState n)=W.walkState (2*n) := by
    simp only [walkState,walkFeature,←Module.End.mul_apply,←pow_add,two_mul]
  rw [he] at hh
  change inner ℝ (W.walkState n) (W.walkState n)=_ at hh
  rw [real_inner_self_eq_norm_sq] at hh
  exact hh.symm
lemma walkState_norm_sq (n : ℕ) : ‖W.walkState n‖^2=∑ x∈W.ball n, (W.walkState n x)^2 :=
  (W.walkState n).norm_sq_eq_sum _ (by
    intro x hx; by_contra hn; exact ((W.walkState n).mem_support x).mp hx (W.walkState_support n hn))
lemma walkState_norm_lower (hD : 0<W.degree) (n : ℕ) : 1≤((W.ball n).card:ℝ)*‖W.walkState n‖^2 := by
  have hmass : (∑ x∈W.ball n, W.walkState n x)=1 := by
    rw [←W.walkState_mass hD n]
    exact (tsum_eq_sum (f:=fun x => W.walkState n x) (s:=W.ball n)
      (fun x hx => W.walkState_support n hx)).symm
  have hc := Finset.sum_mul_sq_le_sq_mul_sq (W.ball n) (fun _ => (1:ℝ)) (fun x => W.walkState n x)
  simpa only [one_mul,hmass,one_pow,Finset.sum_const,nsmul_eq_mul,mul_one,←W.walkState_norm_sq] using hc

lemma transport_averaging (g : W.Aut) (f : FH X) :
    FH.transport g.toEquiv (W.averaging f)=W.averaging (FH.transport g.toEquiv f) := by
  ext x
  simp only [FH.transport_apply,W.averaging_coordinate]
  congr 1
  change (∑ y∈W.neighbors (g.symm x), f y)=∑ y∈W.neighbors x, f (g.symm y)
  rw [←W.neighbors_image g.symm x,Finset.sum_image]
  exact fun a ha b hb h => g.symm.injective h
lemma transport_lazyWalk (g : W.Aut) (f : FH X) :
    FH.transport g.toEquiv (W.lazyWalk f)=W.lazyWalk (FH.transport g.toEquiv f) := by
  simp only [W.lazyWalk_apply,map_smul,map_add,W.transport_averaging]
lemma transport_walkFeature (g : W.Aut) (n : ℕ) (x : X) :
    FH.transport g.toEquiv (W.walkFeature n x)=W.walkFeature n (g x) := by
  induction n with
  | zero => exact FH.transport_delta _ _
  | succ n ih => rw [W.walkFeature_succ,W.transport_lazyWalk,ih,W.walkFeature_succ]
lemma walkFeature_norm (n : ℕ) (x : X) : ‖W.walkFeature n x‖=‖W.walkState n‖ := by
  obtain ⟨g,rfl⟩ := W.transitive W.root x
  rw [←W.transport_walkFeature,LinearIsometryEquiv.norm_map]
lemma walkFeature_average (n : ℕ) (x : X) :
    (∑ y∈W.neighbors x, W.walkFeature n y)=(W.degree:ℝ) • W.averaging (W.walkFeature n x) := by
  have hc : W.averaging.comp W.lazyWalk=W.lazyWalk.comp W.averaging := by
    ext f y
    simp only [LinearMap.comp_apply,W.lazyWalk_apply,map_smul,map_add]
  have hcomm : ∀ n, W.averaging.comp (W.lazyWalk^n)=(W.lazyWalk^n).comp W.averaging := by
    intro n
    induction n with
    | zero => rfl
    | succ n ih =>
      change W.averaging*(W.lazyWalk^(n+1))=(W.lazyWalk^(n+1))*W.averaging
      rw [pow_succ',←mul_assoc,show W.averaging*W.lazyWalk=W.lazyWalk*W.averaging from hc,
        mul_assoc,show W.averaging*W.lazyWalk^n=W.lazyWalk^n*W.averaging from ih,←mul_assoc,←pow_succ']
  have hd (x : X) : (W.degree:ℝ) • W.averaging (FH.delta x)=∑ y∈W.neighbors x, FH.delta y := by
    by_cases hD : W.degree=0
    · have he : W.neighbors x=∅ := Finset.card_eq_zero.mp (by exact (W.neighbors_card x).trans hD)
      simp [hD,he]
    · rw [W.averaging_delta,smul_smul,mul_inv_cancel₀ (by exact_mod_cast hD),one_smul]
  calc
    _ = (W.lazyWalk^n) (∑ y∈W.neighbors x, FH.delta y) := (map_sum _ _ _).symm
    _ = (W.lazyWalk^n) ((W.degree:ℝ) • W.averaging (FH.delta x)) := by rw [hd]
    _ = _ := by rw [map_smul,←LinearMap.comp_apply,←hcomm,LinearMap.comp_apply]; rfl

end CriticalPercolation.HomogeneousAnalysis.Geometry
end
end

end OAI