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

namespace OAI

noncomputable section
open scoped BigOperators Classical ComplexOrder
open Equiv Equiv.Perm Matrix

namespace BinaryCoordinateSweeps.Signed
open Density

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

lemma pinch_trace {I J : Type*} [Fintype I] [DecidableEq J] (f : I → J) (M : Matrix I I ℂ) :
    (pinch f M).trace = M.trace := by
  simp only [Matrix.trace, Matrix.diag, pinch, ite_true]

omit [Fintype A] [DecidableEq A] in
lemma comp_parity_eq_iff (p : A → Bool) (x y : Fin n → A) (g : Equiv.Perm (Fin n)) :
    p ∘ (x ∘ g) = p ∘ (y ∘ g) ↔ p ∘ x = p ∘ y := by
  constructor
  · intro h
    funext i
    simpa only [Function.comp_apply, Equiv.apply_symm_apply] using congrFun h (g.symm i)
  · intro h
    exact congrArg (fun f => f ∘ g) h

omit [Fintype A] [DecidableEq A] in
lemma pinch_block (p : A → Bool) (M : Matrix (Fin n → A) (Fin n → A) ℂ)
    (x y : Fin n → A) (h : p ∘ x ≠ p ∘ y) :
    pinch (fun w => p ∘ w) M x y = 0 := ite_eq_right h

omit [Fintype A] [DecidableEq A] in
lemma pinch_invariant (p : A → Bool) (M : Matrix (Fin n → A) (Fin n → A) ℂ)
    (hM : Invariant p M) (g : Equiv.Perm (Fin n)) (x y : Fin n → A) :
    pinch (fun w => p ∘ w) M (x ∘ g) (y ∘ g) = pinch (fun w => p ∘ w) M x y := by
  simp only [pinch, comp_parity_eq_iff]
  split_ifs with h
  · exact invariant_same_parity p M hM g x y h
  · rfl

omit [DecidableEq A] in
lemma signed_sparse_pinching (p : A → Bool) (M : Matrix (Fin n → A) (Fin n → A) ℂ)
    (hM : M.PosSemidef) (hInv : Invariant p M) :
    (((n+1 : ℕ)^((Fintype.card A)^2) : ℂ) • pinch (fun w => p ∘ w) M - M).PosSemidef := by
  let R : (Fin n → Bool) → (Fin n → Bool) → Prop :=
    fun a b => hamming a b ≤ (Fintype.card A)^2
  have hR : ∀ ⦃left right⦄, R left right → R right left := by
    intro a b h
    change hamming b a ≤ (Fintype.card A)^2
    rw [hamming_symm b a]
    exact h
  have hD : ∀ a : Fin n → Bool, (Finset.univ.filter (R a)).card ≤
      (n+1)^((Fintype.card A)^2) := by
    intro a
    simpa only [Fintype.card_fin] using hamming_degree a ((Fintype.card A)^2)
  have hz : ∀ x y : Fin n → A, ¬R (p ∘ x) (p ∘ y) → M x y = 0 := by
    intro x y h
    by_contra hn
    exact h (invariant_mismatch_card p M hInv x y hn)
  simpa only [Nat.cast_pow] using
    sparse_pinching (fun w => p ∘ w) R hR ((n+1)^((Fintype.card A)^2)) hD hM hz

theorem signed_psd_postselection (n : ℕ) (hn : 0 < n) (p : A → Bool)
    (M : Matrix (Fin n → A) (Fin n → A) ℂ) (hM : M.PosSemidef) (hInv : Invariant p M) :
    ((((n+1 : ℕ)^((Fintype.card A)^2) : ℂ) * M.trace) •
      (∑ c : WordType (MatchedPair p) n, ∑ t : MatchedPair p → ZMod (n+1),
        matrixTensorPower n (reducedPhaseDensity n (matchedEmbedding p) c t)) - M).PosSemidef := by
  let Q := pinch (fun w => p ∘ w) M
  have hQ := pinch_posSemidef (fun w => p ∘ w) hM
  have hd := even_block_postselection n hn p Q hQ (pinch_block p M) (pinch_invariant p M hInv)
  rw [pinch_trace] at hd
  have hc : (0 : ℂ) ≤ ((n+1 : ℕ)^((Fintype.card A)^2) : ℂ) := by
    exact_mod_cast Nat.zero_le ((n+1)^((Fintype.card A)^2))
  have hh := (hd.smul hc).add (signed_sparse_pinching p M hM hInv)
  simp only [smul_sub, smul_smul] at hh
  convert hh using 1; dsimp only [Q]; abel

end BinaryCoordinateSweeps.Signed

end

end OAI