import Mathlib
import OAI.Probability.BinarySweep.Conditional.MainEasyCases
import OAI.Probability.BinarySweep.YoungTheory.YoungDimensionLower
import OAI.Probability.BinarySweep.GridBounds.DenseClosing
import OAI.Probability.BinarySweep.SparseBounds.SparseNumerics
import OAI.Probability.BinarySweep.YoungTheory.YoungTranspose

namespace OAI

noncomputable section

section

open scoped BigOperators Classical
open Filter

namespace BinaryCoordinateSweeps.Young
open Irrep Signed

def minTail (μ : YoungDiagram) : ℕ := min (Fintype.card (Cell μ)-μ.rowLen 0)
  (Fintype.card (Cell μ)-μ.colLen 0)

lemma diagramF_le_rowTail (μ : YoungDiagram) (s : ℕ) (hs : 0 < s)
    (hM : Fintype.card (Cell μ) ≤ s) :
    diagramF μ  ≤  (Fintype.card (Cell μ)-μ.rowLen 0:ℕ)*Real.log s := by
  have hD : (0:ℝ) < Module.finrank ℂ (SpechtSpace μ) := by
    rw [←hilbertSpecht_finrank]
    exact_mod_cast irreducible_finrank_pos (hilbertSpecht μ)
  have hb := (specht_finrank_le_power μ).trans (Nat.pow_le_pow_left hM _)
  have hl := (Real.log_le_log_iff hD (pow_pos (Nat.cast_pos.mpr hs) _)).mpr
    (show (Module.finrank ℂ (SpechtSpace μ):ℝ) ≤
    (s:ℝ)^(Fintype.card (Cell μ)-μ.rowLen 0) by exact_mod_cast hb)
  rw [Real.log_pow] at hl
  exact hl

lemma diagramF_transpose (μ : YoungDiagram) : diagramF μ.transpose=diagramF μ := by
  unfold diagramF
  rw [←specht_finrank_transpose]

lemma minTail_orientation (μ : YoungDiagram) :
    Fintype.card (Tail μ)=minTail μ ∨ Fintype.card (Tail μ.transpose)=minTail μ := by
  have hc := Fintype.card_congr (transposeCells μ)
  rw [card_tail,card_tail,YoungDiagram.rowLen_transpose,←hc]
  exact (le_total (Fintype.card (Cell μ)-μ.rowLen 0) (Fintype.card (Cell μ)-μ.colLen 0)).elim
    (fun h => Or.inl (min_eq_left h).symm) (fun h => Or.inr (min_eq_right h).symm)

lemma diagramF_le_minTail (μ : YoungDiagram) (s : ℕ) (hs : 0 < s)
    (hM : Fintype.card (Cell μ) ≤ s) : diagramF μ ≤ (minTail μ:ℝ)*Real.log s := by
  rcases minTail_orientation μ with ht | ht
  · simpa only [←card_tail,ht] using diagramF_le_rowTail μ s hs hM
  · have hc : Fintype.card (Cell μ.transpose) ≤ s :=
      (Fintype.card_congr (transposeCells μ)).symm.trans_le hM
    simpa only [diagramF_transpose,←card_tail,ht] using diagramF_le_rowTail μ.transpose s hs hc

lemma minTail_le_diagramF (μ : YoungDiagram) :
    (minTail μ:ℝ) ≤ (2/Real.log 2)*diagramF μ := by
  have hl := log_dimension_lower_min_tail μ
  have htwo := Real.log_pos (by norm_num : (1:ℝ) < 2)
  rw [div_mul_eq_mul_div]
  apply (le_div_iff₀ htwo).mpr
  change Real.log 2/2*(minTail μ:ℝ) ≤ diagramF μ at hl
  nlinarith

end BinaryCoordinateSweeps.Young
namespace BinaryCoordinateSweeps
open Young Irrep Signed

lemma const_mul_rpow_eventually (C u v : ℝ) (huv : u < v) : ∀ᶠ s : ℕ in atTop,
    C*(s:ℝ)^u ≤ (s:ℝ)^v := by
  have ht := (tendsto_rpow_atTop (sub_pos.mpr huv)).comp
    (tendsto_natCast_atTop_atTop (R:=ℝ))
  filter_upwards [ht.eventually_ge_atTop C,eventually_ge_atTop (1:ℕ)] with s hs hs1
  have hp : (0:ℝ) < s := by exact_mod_cast hs1
  calc
    _  ≤  (s:ℝ)^(v-u)*(s:ℝ)^u := mul_le_mul_of_nonneg_right hs (Real.rpow_pos_of_pos hp _).le
    _ = _ := by rw [←Real.rpow_add hp]; congr 1; ring

lemma sparse_reduction_eventually : ∀ᶠ s : ℕ in atTop,
    ∀ b r h : ℕ, ∀bits : Fin b → ℕ, gridSize bits=s → 1 ≤ b →
    (∀j,r ≤ bits j) → 400000000 ≤ (r:ℝ)*Real.log 2 →
    ∀H : PathFamily bits h, ∀μ : YoungDiagram, ∀_e : Cell μ ≃ FreeSlot H 0,
    diagramF μ < (s:ℝ)^(399/400:ℝ) →
    ¬((1+cExponent s)*diagramF μ ≤ eExponent s*h*Real.log s-pathCost H) →
    1 ≤ minTail μ ∧ h ≤ 100000*minTail μ ∧
      ((minTail μ+h:ℕ):ℝ) ≤ (s:ℝ)^(1599/1600:ℝ) := by
  filter_upwards [const_mul_rpow_eventually (80000+2/Real.log 2) (399/400) (1599/1600)
    (by norm_num)] with s hs
  intro b r h bits he hb hd hr H μ e hF hnot
  have ha := grid_parameter_allowance hb hd hr H
  rw [he] at ha
  have hLF := grid_log_lower hd
  rw [he] at hLF
  have hbR : (1:ℝ) ≤ b := by exact_mod_cast hb
  have hL : 1 ≤ Real.log s := by nlinarith [mul_le_mul_of_nonneg_left hr (Nat.cast_nonneg b)]
  have hF0 := diagramF_nonneg μ
  have hM : Fintype.card (Cell μ) ≤ s := by
    rw [Fintype.card_congr e,card_freeSlot,he]
    exact Nat.sub_le _ _
  have hp : 0 < s := he ▸ gridSize_pos bits
  have hupper := diagramF_le_minTail μ s hp hM
  have hlow := minTail_le_diagramF μ
  have hallow0 : 0 ≤ eExponent s*h*Real.log s-pathCost H := by
    apply le_trans _ ha.2.2
    unfold e0
    positivity
  have hc : cExponent s ≤ 1 := by have := ha.1; unfold c0 at this; linarith
  have hn := lt_of_not_ge hnot
  have hhL : (h:ℝ)*Real.log s < 80000*diagramF μ := by
    have hh := ha.2.2
    unfold e0 at hh
    nlinarith [mul_le_mul_of_nonneg_right hc hF0]
  have hkpos : 0 < minTail μ := by
    by_contra hk
    have hk0 : minTail μ=0 := by omega
    rw [hk0,Nat.cast_zero,zero_mul] at hupper
    have : diagramF μ=0 := le_antisymm hupper hF0
    rw [this,mul_zero] at hn
    linarith
  have hhk : h ≤ 100000*minTail μ := by
    have hr' : (h:ℝ) ≤ 100000*(minTail μ:ℝ) := by
      have hh' := hhL.trans_le (mul_le_mul_of_nonneg_left hupper (by norm_num))
      have : (h:ℝ) < 80000*minTail μ := by nlinarith
      nlinarith [show (0:ℝ) ≤ minTail μ by positivity]
    exact_mod_cast hr'
  refine ⟨hkpos,hhk,?_⟩
  have hhF : (h:ℝ) ≤ 80000*diagramF μ := by nlinarith
  have hsum : ((minTail μ+h:ℕ):ℝ) ≤ (80000+2/Real.log 2)*diagramF μ := by
    push_cast
    nlinarith
  refine hsum.trans ((mul_le_mul_of_nonneg_left hF.le ?_).trans hs)
  have := Real.log_pos (by norm_num : (1:ℝ) < 2)
  positivity

end BinaryCoordinateSweeps

end

open scoped BigOperators Classical
open Filter

namespace BinaryCoordinateSweeps
open Sparse

lemma outside_card_mul_axis {b : ℕ} (bits : Fin b → ℕ) (j : Fin b) :
    Fintype.card (GridOutside bits j)*2^bits j=gridSize bits := by
  have he := Fintype.card_congr (Equiv.piSplitAt j (fun i => Slot (bits i)))
  change Fintype.card (GridSlot bits)=Fintype.card (Slot (bits j) × GridOutside bits j) at he
  have hs : Fintype.card (Slot (bits j))=2^bits j := by simp [Slot]
  have hg : Fintype.card (GridSlot bits)=gridSize bits := by simp [GridSlot,gridSize,Slot]
  simpa only [Fintype.card_prod,hs,hg,mul_comm] using he.symm

lemma outside_inv_axis_ratio {b : ℕ} (bits : Fin b → ℕ) (j : Fin b) :
    (1:ℝ)/Fintype.card (GridOutside bits j)=(2^bits j:ℕ)/(gridSize bits:ℝ) := by
  have hp : (0:ℝ)<(2^bits j:ℕ) := by positivity
  have he : (Fintype.card (GridOutside bits j):ℝ)*(2^bits j:ℕ)=gridSize bits := by
    exact_mod_cast outside_card_mul_axis bits j
  rw [←he]
  field_simp

lemma many_axis_size_bound {b r : ℕ} {bits : Fin b → ℕ}
    (hb : 16000≤b) (hd : ∀j, r≤bits j ∧ bits j≤2*r) (j : Fin b) :
    ((2^bits j:ℕ):ℝ)≤Real.exp (Real.log (gridSize bits)/8000) := by
  have hbR : (16000:ℝ)≤b := by exact_mod_cast hb
  have hr : 0≤(r:ℝ)*Real.log 2 := mul_nonneg (Nat.cast_nonneg _) (Real.log_nonneg (by norm_num))
  have hl := grid_log_lower (fun j => (hd j).1)
  have ha := mul_le_mul_of_nonneg_right hbR hr
  have hj := mul_le_mul_of_nonneg_right (show (bits j:ℝ)≤2*r by exact_mod_cast (hd j).2)
    (Real.log_nonneg (by norm_num : (1:ℝ)≤2))
  have hp : (0:ℝ)<((2^bits j:ℕ):ℝ) := by positivity
  rw [←Real.exp_log hp]
  apply Real.exp_le_exp.mpr
  simp only [Nat.cast_pow,Nat.cast_ofNat,Real.log_pow]
  linarith

lemma many_collision_base_eventually : ∀ᶠ s : ℕ in atTop,
    ∀ b r h k : ℕ, ∀ bits : Fin b → ℕ, gridSize bits=s → 16000≤b →
    (∀j, r≤bits j ∧ bits j≤2*r) → 1≤(r:ℝ)*Real.log 2 →
    ((k+h:ℕ):ℝ)≤(s:ℝ)^(1599/1600:ℝ) →
    ((k+h:ℕ):ℝ)*(∑j : Fin b, (1:ℝ)/Fintype.card (GridOutside bits j))≤
      Real.exp (-Real.log s/4000) := by
  filter_upwards [log_le_small_rpow_eventually (by norm_num : (0:ℝ)<1/4000)] with s hs
  intro b r h k bits he hb hd hr hk
  have sp : (0:ℝ)<s := by rw [←he]; exact_mod_cast gridSize_pos bits
  have hl := grid_log_lower (fun j => (hd j).1)
  rw [he] at hl
  have hbL : (b:ℝ)≤Real.log s := by nlinarith [mul_le_mul_of_nonneg_left hr (Nat.cast_nonneg b)]
  have hbE : (b:ℝ)≤Real.exp (Real.log s/4000) := by
    refine (hbL.trans hs).trans_eq ?_
    rw [Real.rpow_def_of_pos sp]
    congr 1
    ring
  have hsum : (∑j : Fin b, (1:ℝ)/Fintype.card (GridOutside bits j))≤
      (b:ℝ)*Real.exp (Real.log s/8000)/(s:ℝ) := by
    calc
      _ ≤ ∑_j : Fin b, Real.exp (Real.log s/8000)/(s:ℝ) := by
        apply Finset.sum_le_sum
        intro j _
        rw [outside_inv_axis_ratio,he]
        exact div_le_div_of_nonneg_right (by simpa only [he] using many_axis_size_bound hb hd j) sp.le
      _ = _ := by simp; ring
  have hkE : ((k+h:ℕ):ℝ)≤Real.exp ((1599/1600:ℝ)*Real.log s) := by
    simpa only [Real.rpow_def_of_pos sp,mul_comm] using hk
  calc
    _ ≤ Real.exp ((1599/1600:ℝ)*Real.log s)*
        (Real.exp (Real.log s/4000)*Real.exp (Real.log s/8000)/(s:ℝ)) := by
      apply mul_le_mul hkE
      · exact hsum.trans (div_le_div_of_nonneg_right
          (mul_le_mul_of_nonneg_right hbE (Real.exp_pos _).le) sp.le)
      · positivity
      · positivity
    _ = _ := by
      rw [←Real.exp_log sp,←Real.exp_add,←Real.exp_sub,←Real.exp_add]
      simp only [Real.log_exp]
      congr 1
      ring

end BinaryCoordinateSweeps

end

end OAI