import Mathlib
import OAI.Probability.BinarySweep.SparseBounds.ManySparse
import OAI.Probability.BinarySweep.GridBounds.BalancedGrid

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
open Young Irrep Representation Signed

def SpechtMomentBound (q : ℕ) {b : ℕ} (bits : Fin b → ℕ) (z : ℝ) : Prop :=
  ∀h : ℕ, ∀H : PathFamily bits h, ∀μ : YoungDiagram, ∀e : Cell μ ≃ FreeSlot H 0,
  evenMoment q (groupAverage ((hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom)
    (fun g => (conditionalGroupLaw H z g:ℂ))) ≤
    Real.exp (-cExponent (gridSize bits)*diagramF μ+
      eExponent (gridSize bits)*h*Real.log (gridSize bits)-pathCost H)

lemma spechtMomentBound_enumerated {q b : ℕ} {bits : Fin b → ℕ} {z : ℝ}
    (hB : SpechtMomentBound q bits z) : EnumeratedMomentBound q bits z := by
  intro h H α
  let e : Cell (diagram α) ≃ FreeSlot H 0 :=
    (cellsEquivFin α).trans (Fintype.equivFin _).symm
  have hb := hB h H (diagram α) e
  have he : groupAverage ((hilbertSpecht (diagram α)).comp e.symm.permCongrHom.toMonoidHom)
      (fun g => (conditionalGroupLaw H z g:ℂ)) =
      groupAverage (partitionHilbertRep α)
        (fun a => (conditionalGroupLaw H z ((Fintype.equivFin _).symm.permCongr a):ℂ)) := by
    rw [groupAverage_comp_slots]
    symm
    rw [partitionHilbertRep,groupAverage_comp_slots]
    rfl
  rw [he] at hb
  simpa only [typeF,hilbertSpecht_finrank,diagramF] using hb

lemma hilbert_specht_complete {X V : Type*} [Fintype X] [DecidableEq X]
    [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
    (ρ : Representation ℂ (Equiv.Perm X) V) [ρ.IsIrreducible] :
    ∃(μ : YoungDiagram) (e : Cell μ ≃ X), Nonempty (ρ.Equiv
      ((hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom)) := by
  obtain ⟨μ,e,⟨f⟩⟩ := specht_complete ρ
  let σ : Representation ℂ (Equiv.Perm X) (SpechtSpace μ) := (spechtRep μ).comp e.symm.permCongrHom.toMonoidHom
  let τ : Representation ℂ (Equiv.Perm X) (SpechtHilbert μ) := (hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom
  have a : σ.Equiv τ := .mk (spechtHilbertEquiv μ) (by
    intro g
    apply LinearMap.ext
    intro v
    change spechtHilbertEquiv μ (spechtRep μ _ v)=
      spechtHilbertEquiv μ (spechtRep μ _ ((spechtHilbertEquiv μ).symm (spechtHilbertEquiv μ v)))
    rw [LinearEquiv.symm_apply_apply])
  exact ⟨μ,e,⟨f.trans a⟩⟩

lemma spechtMomentBound_main {q b : ℕ} {bits : Fin b → ℕ} {z : ℝ}
    (hB : SpechtMomentBound q bits z) (h D : ℕ) (H : PathFamily bits h)
    (ρ : Representation ℂ (Equiv.Perm (FreeSlot H 0)) (RepSpace D))
    [ρ.IsIrreducible] (hρ : IsUnitaryRep ρ) :
    logMoment (traceMoment q (conditionalOperator H z ρ)) ≤
      ((-cExponent (gridSize bits)*Real.log D+
        eExponent (gridSize bits)*h*Real.log (gridSize bits)-pathCost H:ℝ):EReal) := by
  obtain ⟨μ,e,⟨f⟩⟩ := hilbert_specht_complete ρ
  have he := equivalent_evenMoment _ _ f hρ (fun g v => hilbertSpecht_unitary μ _ v)
    (fun g => (conditionalGroupLaw H z g:ℂ)) q
  have hD := f.toLinearEquiv.finrank_eq
  rw [finrank_euclideanSpace_fin,hilbertSpecht_finrank] at hD
  apply (logMoment_le_iff_le_exp _ _).mpr
  rw [conditionalMoment_evenMoment,he]
  simpa only [hD,diagramF] using hB h H μ e

end BinaryCoordinateSweeps

end

open scoped BigOperators Classical
open Filter

namespace BinaryCoordinateSweeps
open Young Irrep Representation GridSplit

theorem conditional_moment_main : ConditionalMomentTarget := by
  obtain ⟨S,hS⟩ := sparse_closing_radius
  have hq : 2 ≤ mainMomentPower := by norm_num [mainMomentPower]
  obtain ⟨T,hT⟩ := eventually_atTop.mp (dense_induction_step_eventually mainMomentPower hq)
  let A : ℝ := max ((10:ℝ)^26) ((max S T:ℕ):ℝ)
  have hlog2 : 0 < Real.log 2 := Real.log_pos (by norm_num)
  obtain ⟨r,hr⟩ := exists_nat_gt (max (2:ℝ) (A/Real.log 2))
  have hr2 : 2 ≤ r := by
    have : (2:ℝ) < r := (le_max_left _ _).trans_lt hr
    exact_mod_cast this.le
  have hrA : A ≤ (r:ℝ)*Real.log 2 := by
    have : A/Real.log 2 < r := (le_max_right _ _).trans_lt hr
    exact (div_lt_iff₀ hlog2).mp this |>.le
  have hrL : (10:ℝ)^26 ≤ (r:ℝ)*Real.log 2 := (le_max_left _ _).trans hrA
  have hrM : ((max S T:ℕ):ℝ) ≤ (r:ℝ)*Real.log 2 := (le_max_right _ _).trans hrA
  have hr4 : (4000000000:ℝ) ≤ (r:ℝ)*Real.log 2 := by linarith
  obtain ⟨δ,hδ,hδline,hsp⟩ := hS r hr2 hr4
  let zStar := min δ (oneAxisRadius r)
  have hzStar : 0 < zStar := lt_min hδ (oneAxisRadius_pos r)
  have hlarge {b : ℕ} (hb : 1 ≤ b) (bits : Fin b → ℕ)
      (hd : ∀j,r ≤ bits j ∧ bits j ≤ 2*r) :
      max S T ≤ gridSize bits ∧ (10:ℝ)^26 ≤ Real.log (gridSize bits) := by
    have hl := grid_log_lower (fun j => (hd j).1)
    have hbR : (1:ℝ) ≤ b := by exact_mod_cast hb
    have hr0 : 0 ≤ (r:ℝ)*Real.log 2 := by positivity
    have hbase : (r:ℝ)*Real.log 2 ≤ Real.log (gridSize bits) := by
      have := mul_le_mul_of_nonneg_right hbR hr0
      nlinarith
    refine ⟨?_,hrL.trans hbase⟩
    have hpos : (0:ℝ) < gridSize bits := by exact_mod_cast gridSize_pos bits
    have hexp := Real.log_le_sub_one_of_pos hpos
    have : ((max S T:ℕ):ℝ) ≤ gridSize bits := by linarith [hrM.trans hbase]
    exact_mod_cast this
  have hproof : ∀b : ℕ, 1 ≤ b → ∀bits : Fin b → ℕ,
      (∀j,r ≤ bits j ∧ bits j ≤ 2*r) → ∀z : ℝ, 0 ≤ z → z ≤ zStar →
      SpechtMomentBound mainMomentPower bits z := by
    intro b
    induction b using Nat.strong_induction_on with
    | h b ih =>
      intro hb bits hd z hz hzr h H μ e
      by_cases hb1 : b=1
      · subst b
        have := irreducible_comp_equiv e.symm.permCongrHom (hilbertSpecht μ)
        have hbase := hilbert_conditional_one_axis (by linarith : (400000000:ℝ) ≤ (r:ℝ)*Real.log 2)
          (by omega : 0 < mainMomentPower) bits hd H hz (hzr.trans (min_le_right _ _))
          ((hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom)
          (fun g v => hilbertSpecht_unitary μ _ v)
        simpa only [hilbertSpecht_finrank,diagramF] using hbase
      · have hb2 : 2 ≤ b := by omega
        obtain ⟨m,n,rfl,hm,hn,hmb,hnb,hmn,hnm⟩ := balanced_counts b hb2
        obtain ⟨hsize,hL⟩ := hlarge hb bits hd
        by_cases hF : (gridSize bits:ℝ)^(399/400:ℝ) ≤ diagramF μ
        · obtain ⟨hu,hv,hub,hvb,haxes⟩ := balanced_grid_bounds bits hm hn hmn hnm hd (by linarith)
          apply hT (gridSize bits) ((le_max_right S T).trans hsize) m n h r bits H rfl
            hu hv hub hvb (fun j => (hd j).2) haxes μ e hF z hz
            ((hzr.trans (min_le_left _ _)).trans hδline)
          · apply spechtMomentBound_enumerated
            exact ih m hmb hm (leftBits bits) (fun j => hd (j.castAdd n)) z hz hzr
          · apply spechtMomentBound_enumerated
            exact ih n hnb hn (rightBits bits) (fun j => hd (j.natAdd m)) z hz hzr
        · exact hsp (gridSize bits) ((le_max_left S T).trans hsize) (m+n) h bits rfl hb hd hL H μ e
            (lt_of_not_ge hF) z hz (hzr.trans (min_le_left _ _))
  refine ⟨r,by omega,mainMomentPower,by omega,zStar,hzStar,?_⟩
  intro b hb bits hd h H z hz hzr D ρ hi hρ
  have := hi
  exact spechtMomentBound_main (hproof b hb bits hd z hz hzr) h D H ρ hρ

end BinaryCoordinateSweeps

end

end OAI