import Mathlib.Algebra.BigOperators.Pi
import Mathlib.Data.Fintype.EquivFin
import OAI.Computability.PerfectCompleteness.Algebra.BilinearGramCompressionLemmas
import OAI.Computability.PerfectCompleteness.Algebra.LowerCrossRank
import OAI.Computability.PerfectCompleteness.Algebra.MatrixErasure
import OAI.Computability.PerfectCompleteness.Foundations.PartialTableInverse
import OAI.Computability.PerfectCompleteness.Sampling.RestrictionCrossLaw

namespace OAI


namespace PerfectCompleteness.LowerAffineSliceRank

noncomputable section

open scoped BigOperators Classical
open UniqueGamesTheorem.Integration.BinaryLinear (F2)
open UniqueGamesTheorem.Foundations.Games
open UniqueGamesTheorem.Fourier.MatrixRestrictions
open UniqueGamesTheorem.Fourier.MatrixLevelBridge
open UniqueGamesTheorem.Appendix.RankLevelFilter
open BilinearGramCompression

variable {E : Type*} [AddCommGroup E] [Module F2 E]
  [Fintype E] [FiniteDimensional F2 E]
  {ℓ m : Nat}
  [Fintype (Module.Dual F2 E)]

def matrixRows (X : E →ₗ[F2] (Fin ℓ → F2)) : Fin ℓ → Module.Dual F2 E :=
  fun i => (LinearMap.proj i).comp X

def testedGram (F : Module.Dual F2 E →ₗ[F2] Module.Dual F2 (Module.Dual F2 E))
    (X : E →ₗ[F2] (Fin ℓ → F2)) : Matrix (Fin ℓ) (Fin ℓ) F2 :=
  gram F (matrixRows X)

omit [Fintype E] [FiniteDimensional F2 E] [Fintype (Module.Dual F2 E)] in
theorem coordinate_eq_sum (X : E →ₗ[F2] (Fin ℓ → F2))
    (q : Module.Dual F2 (Fin ℓ → F2)) :
    q.comp X = ∑ k, q (Pi.single k 1) • matrixRows X k := by
  apply LinearMap.ext
  intro e
  simp only [LinearMap.sum_apply, LinearMap.smul_apply, LinearMap.comp_apply,
    matrixRows, LinearMap.proj_apply, smul_eq_mul]
  change q (X e) = ∑ k, q (Pi.single k 1) * X e k
  have hrows := pi_eq_sum_univ' (X e)
  calc
    q (X e) = q (∑ k : Fin ℓ, (X e k) • Pi.single k (1 : F2)) :=
      congrArg q hrows
    _ = ∑ k : Fin ℓ, (X e k) * q (Pi.single k 1) := by
      simp only [map_sum, map_smul, smul_eq_mul]
    _ = _ := Finset.sum_congr rfl (fun k _ => mul_comm _ _)

omit [Fintype E] [FiniteDimensional F2 E] [Fintype (Module.Dual F2 E)] in
theorem coordinate_cross_rank_le
    (F : Module.Dual F2 E →ₗ[F2] Module.Dual F2 (Module.Dual F2 E))
    (X : E →ₗ[F2] (Fin ℓ → F2))
    (left right : Fin m → Module.Dual F2 (Fin ℓ → F2)) :
    Matrix.rank ((fun i j => F ((left i).comp X) ((right j).comp X)) :
      Matrix (Fin m) (Fin m) F2) ≤
      (testedGram F X).rank := by
  have hleft : combinations (matrixRows X)
      (fun i k => left i (Pi.single k 1)) = fun i => (left i).comp X := by
    funext i
    exact (coordinate_eq_sum X (left i)).symm
  have hright : combinations (matrixRows X)
      (fun j k => right j (Pi.single k 1)) = fun j => (right j).comp X := by
    funext j
    exact (coordinate_eq_sum X (right j)).symm
  have h := cross_rank_le F (matrixRows X)
    (fun i k => left i (Pi.single k 1))
    (fun j k => right j (Pi.single k 1))
  rw [hleft, hright] at h
  exact h

section Coordinates

variable {I : Type*} [Fintype I]
  (W : Submodule F2 E) (C' : Submodule F2 (Fin ℓ → F2))
  (b : Module.Basis I F2 C') (sel : (Fin m ⊕ Fin m) → I)

theorem slice_probability_le_of_coordinates (hsel : Function.Injective sel)
    (coordinates : I → Module.Dual F2 (Fin ℓ → F2))
    (hcoordinates : ∀ i, (coordinates i).comp C'.subtype = b.coord i)
    (X : E →ₗ[F2] (Fin ℓ → F2))
    (F : Module.Dual F2 E →ₗ[F2] Module.Dual F2 (Module.Dual F2 E))
    (r s : Nat) (hW : Module.finrank F2 W ≤ r)
    (hrank : s < Module.finrank F2 (LinearMap.range F)) :
    (FiniteDistribution.uniform (Parameter W C')).probability
        (fun A => decide ((testedGram F (translate W C' X A)).rank ≤ 1)) ≤
      (2 : ℝ) ^ m / (2 : ℝ) ^ (s - 2 * r) +
        (2 : ℝ) ^ (2 * m) / (2 : ℝ) ^ (m * m) := by
  have hlaw := RestrictionCrossLaw.crossMatrix_law W C' b sel hsel
    coordinates hcoordinates X F
  have hp := congrArg
    (fun μ : FiniteDistribution (Matrix (Fin m) (Fin m) F2) =>
      μ.probability (fun M => decide (M.rank ≤ 1))) hlaw
  simp only [FiniteDistribution.probability_pushforward] at hp
  have hsource := FiniteDistribution.probability_pushforward
    (Γ := Matrix (Fin m) (Fin m) F2)
    (FiniteDistribution.uniform (Parameter W C'))
    (fun A i j =>
      F ((coordinates (sel (Sum.inl i))).comp (translate W C' X A))
        ((coordinates (sel (Sum.inr j))).comp (translate W C' X A)))
    (fun M => decide (M.rank ≤ 1))
  have hp' := hsource.symm.trans hp
  have hcodim : Module.finrank F2
      (Module.Dual F2 E ⧸ W.dualAnnihilator) ≤ r := by
    rw [DualQuotientRows.codim_dualAnnihilator_eq]
    exact hW
  calc
    _ ≤ (FiniteDistribution.uniform (Parameter W C')).probability
        (fun A => decide (Matrix.rank ((fun i j =>
          F ((coordinates (sel (Sum.inl i))).comp (translate W C' X A))
            ((coordinates (sel (Sum.inr j))).comp (translate W C' X A))) :
              Matrix (Fin m) (Fin m) F2) ≤ 1)) := by
      apply FiniteDistribution.probability_mono
      intro A hA
      apply decide_eq_true
      exact (coordinate_cross_rank_le F (translate W C' X A)
        (fun i => coordinates (sel (Sum.inl i)))
        (fun j => coordinates (sel (Sum.inr j)))).trans (of_decide_eq_true hA)
    _ = _ := hp'
    _ ≤ _ := LowerCrossRank.cross_rank_probability_le_of_rank_gt F W.dualAnnihilator
      (fun i => (coordinates (sel (Sum.inl i))).comp X)
      (fun j => (coordinates (sel (Sum.inr j))).comp X) r s hcodim hrank

end Coordinates

theorem slice_rank_probability_le_of_rank_gt
    (W : Submodule F2 E) (C' : Submodule F2 (Fin ℓ → F2))
    (X : E →ₗ[F2] (Fin ℓ → F2))
    (F : Module.Dual F2 E →ₗ[F2] Module.Dual F2 (Module.Dual F2 E))
    (r s : Nat) (horder : order W C' ≤ r) (hrows : 2 * m + r ≤ ℓ)
    (hrank : s < Module.finrank F2 (LinearMap.range F)) :
    (FiniteDistribution.uniform (Parameter W C')).probability
        (fun A => decide ((testedGram F (translate W C' X A)).rank ≤ 1)) ≤
      (2 : ℝ) ^ m / (2 : ℝ) ^ (s - 2 * r) +
        (2 : ℝ) ^ (2 * m) / (2 : ℝ) ^ (m * m) := by
  let b := Module.finBasis F2 C'
  have hW : Module.finrank F2 W ≤ r := (Nat.le_add_right _ _).trans horder
  have hdim : 2 * m ≤ Module.finrank F2 C' := by
    have htotal := C'.finrank_quotient_add_finrank
    have hfull : Module.finrank F2 (Fin ℓ → F2) = ℓ := by
      simp [Module.finrank_fintype_fun_eq_card]
    rw [hfull] at htotal
    unfold order at horder
    omega
  obtain ⟨sel⟩ := Function.Embedding.nonempty_of_card_le
    (show Fintype.card (Fin m ⊕ Fin m) ≤
      Fintype.card (Fin (Module.finrank F2 C')) by
      simpa only [Fintype.card_sum, Fintype.card_fin, two_mul] using hdim)
  let coordinates : Fin (Module.finrank F2 C') → Module.Dual F2 (Fin ℓ → F2) :=
    fun i => Subspace.dualLift C' (b.coord i)
  have hcoordinates : ∀ i, (coordinates i).comp C'.subtype = b.coord i := by
    intro i
    apply LinearMap.ext
    intro x
    change Subspace.dualLift C' (b.coord i) (x : Fin ℓ → F2) = b.coord i x
    exact Subspace.dualLift_of_subtype (φ := b.coord i) x
  exact slice_probability_le_of_coordinates W C' b sel sel.injective
    coordinates hcoordinates X F r s hW hrank


variable {Y : Type*} [Fintype Y]
  (f : (E →ₗ[F2] (Fin ℓ → F2)) → Option Y)
  (form : Y → Module.Dual F2 E →ₗ[F2] Module.Dual F2 (Module.Dual F2 E))

private theorem probability_eq_expect_indicator {A : Type*} [Fintype A] [Nonempty A]
    (event : A → Bool) :
    (FiniteDistribution.uniform A).probability event =
      𝔼 a : A, if event a then (1 : ℝ) else 0 := by
  have h : (FiniteDistribution.uniform A).probability event =
      (FiniteDistribution.uniform A).expectation (fun a => if event a then (1 : ℝ) else 0) := by
    simp [FiniteDistribution.probability, FiniteDistribution.expectation, mul_ite]
  rw [h, FiniteDistribution.expectation_uniform, Fintype.expect_eq_sum_div_card]

omit [Fintype Y] in
theorem dense_value_rank_le
    (tested : ∀ X y, f X = some y → (testedGram (form y) X).rank ≤ 1)
    (W : Submodule F2 E) (C' : Submodule F2 (Fin ℓ → F2))
    (X : E →ₗ[F2] (Fin ℓ → F2)) (y : Y)
    (r s : Nat) (ρ : ℝ) (horder : order W C' ≤ r) (hrows : 2 * m + r ≤ ℓ)
    (herror : (2 : ℝ) ^ m / (2 : ℝ) ^ (s - 2 * r) +
      (2 : ℝ) ^ (2 * m) / (2 : ℝ) ^ (m * m) ≤ ρ)
    (hdense : ρ < 𝔼 A : Parameter W C',
      restrict (PartialTableInverse.indicator f y) W C' X A) :
    Module.finrank F2 (LinearMap.range (form y)) ≤ s := by
  by_contra h
  have hbound := slice_rank_probability_le_of_rank_gt W C' X (form y) r s
    horder hrows (Nat.lt_of_not_ge h)
  have hdom : (𝔼 A : Parameter W C',
      restrict (PartialTableInverse.indicator f y) W C' X A) ≤
      (FiniteDistribution.uniform (Parameter W C')).probability
        (fun A => decide ((testedGram (form y) (translate W C' X A)).rank ≤ 1)) := by
    rw [probability_eq_expect_indicator]
    apply Finset.expect_le_expect
    intro A _
    by_cases hf : f (translate W C' X A) = some y
    · simp [restrict, PartialTableInverse.indicator, hf, tested _ _ hf]
    · simp only [restrict, PartialTableInverse.indicator, ite_eq_right hf]
      split_ifs <;> norm_num
  exact (not_le_of_gt hdense) (hdom.trans (hbound.trans herror))

theorem high_rank_agreement_lt
    [Fintype (E →ₗ[F2] (Fin ℓ → F2))]
    [Fintype ((Fin ℓ → F2) →ₗ[F2] E)]
    (tested : ∀ X y, f X = some y → (testedGram (form y) X).rank ≤ 1)
    (r s : Nat) (ρ η : ℝ) (hm : 0 < m)
    (hρ : 0 < ρ) (hρ1 : ρ < 1)
    (hconstants : levelCutoffConstant r ρ + node (r + 1) < η)
    (hrows : 2 * m + r ≤ ℓ)
    (herror : (2 : ℝ) ^ m / (2 : ℝ) ^ (s - 2 * r) +
      (2 : ℝ) ^ (2 * m) / (2 : ℝ) ^ (m * m) ≤ ρ) :
    PartialTableInverse.nonzeroAgreement
      (MatrixErasure.erase f (fun X => ∃ y, f X = some y ∧
        Module.finrank F2 (LinearMap.range (form y)) ≤ s)) < η := by
  have hℓ : 0 < ℓ := by omega
  let : Nonempty (Fin ℓ) := ⟨⟨0, hℓ⟩⟩
  let T := fun X => ∃ y, f X = some y ∧
    Module.finrank F2 (LinearMap.range (form y)) ≤ s
  let g := MatrixErasure.erase f T
  have htested : ∀ X y, g X = some y → (testedGram (form y) X).rank ≤ 1 := by
    intro X y h
    exact tested X y ((MatrixErasure.erase_eq_some_iff f T X y).mp h).2
  by_contra h
  have hagreement : η ≤ PartialTableInverse.nonzeroAgreement g := le_of_not_gt h
  obtain ⟨y, W, C', X, horder, hdense⟩ :=
    PartialTableInverse.exists_dense_slice_nonzero r ρ η hρ hρ1 hconstants g hagreement
  have hrank := dense_value_rank_le g form htested W C' X y r s ρ horder hrows herror hdense
  have hnone (A : Parameter W C') : g (translate W C' X A) ≠ some y := by
    intro h
    have he := (MatrixErasure.erase_eq_some_iff f T _ y).mp h
    exact he.1 ⟨y, he.2, hrank⟩
  have hzero : (𝔼 A : Parameter W C',
      restrict (PartialTableInverse.indicator g y) W C' X A) = 0 := by
    apply Finset.expect_eq_zero
    intro A _
    simp [restrict, PartialTableInverse.indicator, hnone A]
  rw [hzero] at hdense
  exact (not_lt_of_ge hρ.le) hdense


end
end PerfectCompleteness.LowerAffineSliceRank

end OAI