lean/OAI/Probability/BinarySweep/TensorBounds/SignedCommutant.lean

import Mathlib
import OAI.Probability.BinarySweep.TensorBounds.EvenPostselection

namespace OAI

noncomputable section

section

open scoped BigOperators Classical
open Equiv Equiv.Perm Matrix

namespace BinaryCoordinateSweeps.Signed
open Density

variable {A : Type*} [Fintype A] [DecidableEq A] {n : ℕ}

def invariantSubspace (p : A → Bool) (n : ℕ) :
    Submodule ℂ (Matrix (Fin n → A) (Fin n → A) ℂ) where
  carrier := {M | Invariant p M}
  zero_mem' := by intro g x y; simp
  add_mem' := by
    intro M N hM hN g x y
    simp only [Matrix.add_apply, hM g x y, hN g x y, mul_add]
  smul_mem' := by
    intro c M hM g x y
    simp only [Matrix.smul_apply, smul_eq_mul, hM g x y]
    ring

abbrev RealizedType (A : Type*) [Fintype A] [DecidableEq A] (n : ℕ) :=
  Set.range (wordType (A := A × A) n)

def typeRepresentative (c : RealizedType A n) : Fin n → A × A := c.property.choose

lemma typeRepresentative_type (c : RealizedType A n) :
    wordType n (typeRepresentative c) = c.val := c.property.choose_spec

def invariantCode (p : A → Bool) (n : ℕ) :
    invariantSubspace p n →ₗ[ℂ] (RealizedType A n → ℂ) where
  toFun M c := M.val (Prod.fst ∘ typeRepresentative c) (Prod.snd ∘ typeRepresentative c)
  map_add' _ _ := rfl
  map_smul' _ _ := rfl

lemma invariantCode_injective (p : A → Bool) (n : ℕ) :
    Function.Injective (invariantCode p n) := by
  intro M N h
  apply Subtype.ext
  ext x y
  let w : Fin n → A × A := fun i => (x i,y i)
  let c : RealizedType A n := ⟨wordType n w, ⟨w,rfl⟩⟩
  have hc : wordCounts w = wordCounts (typeRepresentative c) :=
    (wordType_eq_iff n w _).mp (typeRepresentative_type c).symm
  obtain ⟨g,hg⟩ := exists_perm_eq_of_wordCounts hc
  have hx : (Prod.fst ∘ typeRepresentative c) ∘ g = x := by
    funext i
    exact congrArg Prod.fst (hg i)
  have hy : (Prod.snd ∘ typeRepresentative c) ∘ g = y := by
    funext i
    exact congrArg Prod.snd (hg i)
  have hm := M.property g (Prod.fst ∘ typeRepresentative c) (Prod.snd ∘ typeRepresentative c)
  have hn := N.property g (Prod.fst ∘ typeRepresentative c) (Prod.snd ∘ typeRepresentative c)
  rw [hx,hy] at hm hn
  rw [hm,hn]
  exact congrArg (fun z : ℂ => signC (p ∘ (Prod.fst ∘ typeRepresentative c)) g⁻¹ *
    signC (p ∘ (Prod.snd ∘ typeRepresentative c)) g⁻¹ * z) (congrFun h c)

lemma invariantSubspace_finrank (p : A → Bool) (n : ℕ) :
    Module.finrank ℂ (invariantSubspace p n) ≤ (n+1)^((Fintype.card A)^2) := by
  let : Fintype (RealizedType A n) := Fintype.ofFinite _
  have h := LinearMap.finrank_le_finrank_of_injective (f := invariantCode p n)
    (invariantCode_injective p n)
  rw [Module.finrank_pi] at h
  have hc := Fintype.card_le_of_injective (fun c : RealizedType A n => c.val) Subtype.val_injective
  have ht := card_types_le (A := A × A) n
  simp only [Fintype.card_coe, Fintype.card_prod, ← pow_two] at hc ht
  exact h.trans (hc.trans ht)

omit [Fintype A] in
lemma act_single_comp (p : A → Bool) (g : Equiv.Perm (Fin n)) (y : Fin n → A) :
    act p g (Pi.single (y ∘ g) (1 : ℂ)) =
      signC (p ∘ y) g⁻¹ • Pi.single y (1 : ℂ) := by
  funext x
  change signC (p ∘ x) g⁻¹ * ((Pi.single (y ∘ g) (1 : ℂ) : (Fin n → A) → ℂ) (x ∘ g)) = _
  by_cases h : x=y
  · subst x
    simp
  · have hg : x ∘ g ≠ y ∘ g := by
      intro he
      apply h
      funext i
      simpa only [Function.comp_apply, Equiv.apply_symm_apply] using congrFun he (g.symm i)
    simp [h, hg]

lemma intertwiner_matrix_invariant (p : A → Bool)
    (f : Representation.IntertwiningMap (tensorRep p n) (tensorRep p n)) :
    Invariant p (LinearMap.toMatrix' f.toLinearMap) := by
  intro g x y
  have h := congrFun (Representation.IntertwiningMap.isIntertwining _ _ f g (Pi.single (y ∘ g) (1 : ℂ))) x
  change f (act p g (Pi.single (y ∘ g) 1)) x = signC (p ∘ x) g⁻¹ * f (Pi.single (y ∘ g) 1) (x ∘ g) at h
  rw [act_single_comp, map_smul] at h
  simp only [Pi.smul_apply, smul_eq_mul] at h
  simp only [LinearMap.toMatrix'_apply, Representation.IntertwiningMap.toLinearMap_apply]
  have hs := signC_sq (p ∘ x) g⁻¹
  calc
    _ = (signC (p ∘ x) g⁻¹ * signC (p ∘ x) g⁻¹) * f (Pi.single (y ∘ g) 1) (x ∘ g) := by rw [hs,one_mul]
    _ = _ := by rw [mul_assoc, ← h]; ring

def commutantToInvariant (p : A → Bool) (n : ℕ) :
    Representation.IntertwiningMap (tensorRep p n) (tensorRep p n) →ₗ[ℂ]
      invariantSubspace p n where
  toFun f := ⟨LinearMap.toMatrix' f.toLinearMap, intertwiner_matrix_invariant p f⟩
  map_add' f g := by apply Subtype.ext; simp
  map_smul' c f := by apply Subtype.ext; simp

lemma commutantToInvariant_injective (p : A → Bool) (n : ℕ) :
    Function.Injective (commutantToInvariant p n) := by
  intro f g h
  apply Representation.IntertwiningMap.toLinearMap_injective
  apply LinearMap.toMatrix'.injective
  exact congrArg Subtype.val h

theorem tensor_commutant_finrank (p : A → Bool) (n : ℕ) :
    Module.finrank ℂ (Representation.IntertwiningMap (tensorRep p n) (tensorRep p n)) ≤
      (n+1)^((Fintype.card A)^2) :=
  (LinearMap.finrank_le_finrank_of_injective (f := commutantToInvariant p n)
    (commutantToInvariant_injective p n)).trans (invariantSubspace_finrank p n)

end BinaryCoordinateSweeps.Signed

end

open scoped BigOperators Classical ComplexOrder
open Equiv Equiv.Perm Matrix

namespace BinaryCoordinateSweeps.Signed
variable {A : Type*} [Fintype A] {n : ℕ}

abbrev TensorSpace (A : Type*) (n : ℕ) := EuclideanSpace ℂ (Fin n → A)

def coeffEquiv (A : Type*) [Fintype A] (n : ℕ) :
    TensorSpace A n ≃ₗ[ℂ] ((Fin n → A) → ℂ) := WithLp.linearEquiv 2 ℂ _

def wordReorder (g : Equiv.Perm (Fin n)) : (Fin n → A) ≃ (Fin n → A) where
  toFun x := x ∘ g
  invFun x := x ∘ g.symm
  left_inv x := by ext i; simp
  right_inv x := by ext i; simp

def actHilbert (p : A → Bool) (g : Equiv.Perm (Fin n)) :
    TensorSpace A n →ₗ[ℂ] TensorSpace A n := (coeffEquiv A n).symm.conj (act p g)

lemma actHilbert_apply (p : A → Bool) (g : Equiv.Perm (Fin n)) (v : TensorSpace A n) (x) :
    actHilbert p g v x = signC (p ∘ x) g⁻¹ * v (x ∘ g) := rfl

lemma actHilbert_inner (p : A → Bool) (g : Equiv.Perm (Fin n)) (v w : TensorSpace A n) :
    inner ℂ (actHilbert p g v) (actHilbert p g w) = inner ℂ v w := by
  simp only [PiLp.inner_apply, actHilbert_apply, RCLike.inner_apply, map_mul,
    starRingEnd_apply, signC_star]
  have he (x : Fin n → A) : signC (p ∘ x) g⁻¹ * w (x ∘ g) *
      (signC (p ∘ x) g⁻¹ * star (v (x ∘ g))) = w (x ∘ g) * star (v (x ∘ g)) := by
    calc
      _ = (signC (p ∘ x) g⁻¹ * signC (p ∘ x) g⁻¹) *
          (w (x ∘ g) * star (v (x ∘ g))) := by ring
      _ = _ := by rw [signC_sq, one_mul]
  simp_rw [he]
  exact Equiv.sum_comp (wordReorder g) (fun x => w x * star (v x))

def actionIsometry (p : A → Bool) (g : Equiv.Perm (Fin n)) :
    TensorSpace A n →ₗᵢ[ℂ] TensorSpace A n := (actHilbert p g).isometryOfInner (actHilbert_inner p g)

def hilbertSubspace (S : Submodule ℂ ((Fin n → A) → ℂ)) : Submodule ℂ (TensorSpace A n) :=
  S.map (coeffEquiv A n).symm.toLinearMap

lemma hilbertSubspace_finrank (S : Submodule ℂ ((Fin n → A) → ℂ)) :
    Module.finrank ℂ (hilbertSubspace S) = Module.finrank ℂ S :=
  (Submodule.equivMapOfInjective (coeffEquiv A n).symm.toLinearMap
    (coeffEquiv A n).symm.injective S).finrank_eq.symm

lemma hilbertSubspace_map (p : A → Bool) (S : Submodule ℂ ((Fin n → A) → ℂ))
    (hS : ∀ g, S.map (act p g) = S) (g : Equiv.Perm (Fin n)) :
    (hilbertSubspace S).map (actHilbert p g) = hilbertSubspace S := by
  apply le_antisymm
  · rintro _ ⟨u,⟨v,hv,rfl⟩,rfl⟩
    refine ⟨act p g v, ?_, ?_⟩
    · rw [← hS g]
      exact ⟨v,hv,rfl⟩
    · simp only [actHilbert, LinearEquiv.conj_apply, LinearMap.comp_apply,
      LinearEquiv.coe_coe, LinearEquiv.symm_symm, LinearEquiv.apply_symm_apply]
  · rintro _ ⟨v,hv,rfl⟩
    have hm : v ∈ S.map (act p g) := (hS g).symm ▸ hv
    obtain ⟨w,hw,rfl⟩ := hm
    refine ⟨(coeffEquiv A n).symm w, ⟨w,hw,rfl⟩, ?_⟩
    simp only [actHilbert, LinearEquiv.conj_apply, LinearMap.comp_apply,
      LinearEquiv.coe_coe, LinearEquiv.symm_symm, LinearEquiv.apply_symm_apply]

end BinaryCoordinateSweeps.Signed

end

end OAI