import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Specht.DualPolytabloid

namespace OAI

/-! Common Basis. -/

section

noncomputable section
open scoped TensorProduct
namespace Saxl

theorem finite_polynomials_common_point {ι σ : Type*} [Fintype ι]
    (p : ι → MvPolynomial σ ℂ) (hp : ∀ i, p i ≠ 0)
    (q : MvPolynomial σ ℂ) (hq : q ≠ 0) :
    ∃ v : σ → ℂ, MvPolynomial.eval v q ≠ 0 ∧
      ∀ i, MvPolynomial.eval v (p i) ≠ 0 := by
  classical
  have hprod : q * ∏ i, p i ≠ 0 := mul_ne_zero hq
    (Finset.prod_ne_zero_iff.mpr (fun i _ => hp i))
  have he : ∃ v : σ → ℂ, MvPolynomial.eval v (q * ∏ i, p i) ≠ 0 := by
    by_contra hn
    push Not at hn
    apply hprod
    exact MvPolynomial.funext (fun v => by simpa only [map_zero] using hn v)
  obtain ⟨v,hv⟩ := he
  simp only [map_mul, map_prod, mul_ne_zero_iff, Finset.prod_ne_zero_iff,
    Finset.mem_univ, forall_const] at hv
  exact ⟨v,hv⟩

theorem wordMap_common_invertible {ι : Type*} [Fintype ι] (n : ι → ℕ) (d : ℕ)
    (x y : ∀ i, WordSpace (n i) d)
    (h : ∀ i, ∃ L : Fin d → Fin d → ℂ,
      dotProduct (wordMap L (x i)) (y i) ≠ 0) :
    ∃ L : Fin d → Fin d → ℂ, (Matrix.of L).det ≠ 0 ∧
      ∀ i, dotProduct (wordMap L (x i)) (y i) ≠ 0 := by
  have hp (i) : pairingPolynomial (x i) (y i) ≠ 0 := by
    obtain ⟨L,hL⟩ := h i
    intro hz
    apply hL
    rw [← pairingPolynomial_eval, hz, map_zero]
  obtain ⟨v,hv,hp⟩ := finite_polynomials_common_point
    (fun i => pairingPolynomial (x i) (y i)) hp
    (Matrix.mvPolynomialX (Fin d) (Fin d) ℂ).det
    (Matrix.det_mvPolynomialX_ne_zero (Fin d) ℂ)
  refine ⟨fun a b => v (a,b), ?_, ?_⟩
  · exact (Matrix.eval_det_mvPolynomialX (Fin d) ℂ v) ▸ hv
  · intro i
    exact (pairingPolynomial_eval (x i) (y i) (fun a b => v (a,b))) ▸ hp i

lemma wordMap_letterLift {n a b c : ℕ} (f : Fin a → Fin b)
    (L : Fin b → Fin c → ℂ) (x : WordSpace n a) :
    wordMap L (letterLift f x) = wordMap (fun i j => L (f i) j) x := by
  classical
  have h : (wordMap L).comp (letterLift f) = wordMap (fun i j => L (f i) j) (n := n) := by
    apply Representation.IntertwiningMap.ext
    apply LinearMap.pi_ext
    intro w c
    have he : (Pi.single w c : WordSpace n a) = c • Pi.single w 1 := by
      rw [← Pi.single_smul, smul_eq_mul, mul_one]
    rw [he, map_smul, map_smul]
    congr 1
    change wordMap L (letterLift f (Pi.single w 1)) = wordMap _ (Pi.single w 1)
    rw [letterLift_single]
    ext v
    simp only [wordMap_single, Function.comp_apply]
  exact congrArg (fun F => F x) h

def extendAlphabetMap {a b : ℕ} (_h : a ≤ b) (L : Fin a → Fin b → ℂ) :
    (Fin b → Fin b → ℂ) := fun i j => if hi : i.val < a then L ⟨i.val,hi⟩ j else 0

lemma extendAlphabetMap_apply {a b : ℕ} (h : a ≤ b)
    (L : Fin a → Fin b → ℂ) (i : Fin a) (j : Fin b) :
    extendAlphabetMap h L (Fin.castLE h i) j = L i j := by
  simp [extendAlphabetMap, i.isLt]

theorem dual_polytabloid_necessary_basis {n d : ℕ} {μ : YoungDiagram}
    (t : Tableau n μ) (u : WordSpace n d) (hμ : μ.colLen 0 ≤ d)
    (f : Representation.IntertwiningMap (spechtRep t)
      (cyclic (wordRep n d) u).toRepresentation) (hf : f ≠ 0) :
    ∃ (g : Equiv.Perm (Fin n)) (L : Fin d → Fin d → ℂ), (Matrix.of L).det ≠ 0 ∧
      dotProduct (wordMap L (letterLift (Fin.castLE hμ)
        (wordRep n (μ.colLen 0) g (polytabloid t)))) u ≠ 0 := by
  obtain ⟨g,L,hL⟩ := dual_polytabloid_necessary t u f hf
  let x := letterLift (Fin.castLE hμ) (wordRep n (μ.colLen 0) g (polytabloid t))
  have hex : ∃ M : Fin d → Fin d → ℂ, dotProduct (wordMap M x) u ≠ 0 := by
    refine ⟨extendAlphabetMap hμ L, ?_⟩
    simpa only [x, wordMap_letterLift, extendAlphabetMap_apply] using hL
  obtain ⟨M,hM,hm⟩ := wordMap_common_invertible (ι := Unit) (fun _ => n) d
    (fun _ => x) (fun _ => u) (fun _ => hex)
  exact ⟨g,M,hM,hm ()⟩

theorem dual_polytabloid_basis_iff {n d : ℕ} {μ : YoungDiagram}
    (t : Tableau n μ) (u : WordSpace n d) (hμ : μ.colLen 0 ≤ d) :
    (∃ f : Representation.IntertwiningMap (spechtRep t)
      (cyclic (wordRep n d) u).toRepresentation, f ≠ 0) ↔
    ∃ (g : Equiv.Perm (Fin n)) (L : Fin d → Fin d → ℂ), (Matrix.of L).det ≠ 0 ∧
      dotProduct (wordMap L (letterLift (Fin.castLE hμ)
        (wordRep n (μ.colLen 0) g (polytabloid t)))) u ≠ 0 := by
  constructor
  · rintro ⟨f,hf⟩
    exact dual_polytabloid_necessary_basis t u hμ f hf
  · rintro ⟨g,L,_,h⟩
    rw [wordMap_letterLift] at h
    exact (dual_polytabloid_iff t u).mpr ⟨g,_,h⟩

end Saxl
end
end

end OAI