import OAI.InformationTheory.SecretKey.Model

namespace OAI

noncomputable section

open scoped MatrixOrder ComplexOrder Kronecker

open Matrix

namespace ZeroKey

section MatrixPolar

universe v43_0

variable {ι : Type v43_0} [inst43_0 : Fintype ι] [inst43_1 : DecidableEq ι]

theorem exists_unitary_polar (A : Matrix ι ι ℂ) :
    ∃ U : Matrix.unitaryGroup ι ℂ, A = (U : Matrix ι ι ℂ) * CFC.sqrt (Aᴴ * A) := by
  apply exists_unitary_mul_of_gram_eq
  rw [(CFC.sqrt_nonneg (Aᴴ * A)).posSemidef.isHermitian.eq]
  exact (CFC.sqrt_mul_sqrt_self (Aᴴ * A)
    (Matrix.posSemidef_conjTranspose_mul_self A).nonneg).symm

end MatrixPolar

section TraceNorm

universe v84_0

variable {ι : Type v84_0} [inst84_0 : Fintype ι] [inst84_1 : DecidableEq ι]

omit inst84_1 in
lemma re_trace_nonneg [DecidableEq ι] {S : Matrix ι ι ℂ} (hS : S.PosSemidef) :
    0 ≤ (trace S).re := (RCLike.nonneg_iff.mp hS.trace_nonneg).1

lemma re_trace_mul_nonneg {S T : Matrix ι ι ℂ}
    (hS : S.PosSemidef) (hT : T.PosSemidef) : 0 ≤ (trace (S * T)).re := by
  let B := CFC.sqrt S
  have hB : Bᴴ = B := (CFC.sqrt_nonneg S).posSemidef.isHermitian.eq
  have hBB : B * B = S := CFC.sqrt_mul_sqrt_self S hS.nonneg
  have h := re_trace_nonneg (hT.mul_mul_conjTranspose_same B)
  rwa [hB, Matrix.trace_mul_cycle, hBB] at h

omit inst84_1 in
lemma re_trace_star_mul [DecidableEq ι] {S W : Matrix ι ι ℂ} (hS : S.IsHermitian) :
    (trace (Wᴴ * S)).re = (trace (W * S)).re := by
  have h : Wᴴ * S = (S * W)ᴴ := by simp [hS.eq]
  rw [h, Matrix.trace_conjTranspose, Matrix.trace_mul_comm S W]
  rfl

lemma re_trace_unitary_mul_le {S : Matrix ι ι ℂ} (hS : S.PosSemidef)
    (W : Matrix.unitaryGroup ι ℂ) : (trace ((W : Matrix ι ι ℂ) * S)).re ≤ (trace S).re := by
  let V : Matrix ι ι ℂ := W
  have hV : Vᴴ * V = 1 := W.prop.1
  have hp := re_trace_mul_nonneg (Matrix.posSemidef_conjTranspose_mul_self (V - 1)) hS
  have hexp : (V - 1)ᴴ * (V - 1) * S = S + S - V * S - Vᴴ * S := by
    simp only [Matrix.conjTranspose_sub, Matrix.conjTranspose_one, sub_mul, mul_sub,
      hV, one_mul, mul_one]
    noncomm_ring
  rw [hexp, Matrix.trace_sub, Matrix.trace_sub, Matrix.trace_add,
    Complex.sub_re, Complex.sub_re, Complex.add_re, re_trace_star_mul hS.isHermitian] at hp
  change (trace (V * S)).re ≤ (trace S).re
  linarith

lemma traceNorm_nonneg (A : Matrix ι ι ℂ) : 0 ≤ traceNorm A :=
  re_trace_nonneg (CFC.sqrt_nonneg (Aᴴ * A)).posSemidef

lemma re_trace_unitary_mul_le_traceNorm (A : Matrix ι ι ℂ)
    (W : Matrix.unitaryGroup ι ℂ) :
    (trace ((W : Matrix ι ι ℂ) * A)).re ≤ traceNorm A := by
  obtain ⟨U, hU⟩ := exists_unitary_polar A
  have h := re_trace_unitary_mul_le (CFC.sqrt_nonneg (Aᴴ * A)).posSemidef (W * U)
  change (trace (((W : Matrix ι ι ℂ) * (U : Matrix ι ι ℂ)) * CFC.sqrt (Aᴴ * A))).re ≤ _ at h
  rw [Matrix.mul_assoc, ← hU] at h
  exact h

lemma exists_unitary_traceNorm (A : Matrix ι ι ℂ) :
    ∃ U : Matrix.unitaryGroup ι ℂ, (trace ((U : Matrix ι ι ℂ) * A)).re = traceNorm A := by
  obtain ⟨U, hU⟩ := exists_unitary_polar A
  refine ⟨star U, ?_⟩
  change (trace ((U : Matrix ι ι ℂ)ᴴ * A)).re = _
  nth_rw 1 [hU]
  rw [← Matrix.mul_assoc, show (U : Matrix ι ι ℂ)ᴴ * U = 1 from U.prop.1, one_mul]
  rfl

lemma traceNorm_add_le (A B : Matrix ι ι ℂ) :
    traceNorm (A + B) ≤ traceNorm A + traceNorm B := by
  obtain ⟨U, hU⟩ := exists_unitary_traceNorm (A + B)
  rw [← hU, mul_add, Matrix.trace_add, Complex.add_re]
  exact add_le_add (re_trace_unitary_mul_le_traceNorm A U)
    (re_trace_unitary_mul_le_traceNorm B U)

lemma trace_re_unitary_conjugate (A : Matrix ι ι ℂ) (U : Matrix.unitaryGroup ι ℂ) :
    trace ((U : Matrix ι ι ℂ) * A * (U : Matrix ι ι ℂ)ᴴ) = trace A := by
  rw [Matrix.trace_mul_cycle, show (U : Matrix ι ι ℂ)ᴴ * U = 1 from U.prop.1, one_mul]

end TraceNorm

section Frobenius

universe v155_0 v155_1

variable {ι : Type v155_0} {κ : Type v155_1} [inst155_0 : Fintype ι] [inst155_1 : Fintype κ] [inst155_2 : DecidableEq ι]

omit inst155_2 in
lemma trace_mul_conjTranspose_eq_inner [DecidableEq ι] (A B : Matrix ι κ ℂ) :
    trace (A * Bᴴ) = inner ℂ (matrixVector B) (matrixVector A) := by
  simp [matrixVector, EuclideanSpace.inner_toLp_toLp, Matrix.trace, Matrix.mul_apply,
    Matrix.conjTranspose_apply, dotProduct, Fintype.sum_prod_type]

lemma norm_matrixVector (A : Matrix ι κ ℂ) :
    ‖matrixVector A‖ = Real.sqrt (trace (A * Aᴴ)).re := by
  rw [trace_mul_conjTranspose_eq_inner]
  exact norm_eq_sqrt_re_inner (𝕜 := ℂ) (matrixVector A)

lemma re_trace_mul_conjTranspose_le (A B : Matrix ι κ ℂ) :
    (trace (A * Bᴴ)).re ≤ Real.sqrt ((trace (A * Aᴴ)).re * (trace (B * Bᴴ)).re) := by
  rw [trace_mul_conjTranspose_eq_inner A B, Real.sqrt_mul
    (re_trace_nonneg (Matrix.posSemidef_self_mul_conjTranspose A))]
  change RCLike.re (inner ℂ (matrixVector B) (matrixVector A)) ≤ _
  calc
    _ ≤ ‖matrixVector B‖ * ‖matrixVector A‖ := re_inner_le_norm _ _
    _ = _ := by rw [norm_matrixVector, norm_matrixVector, mul_comm]

lemma traceNorm_mul_conjTranspose_le (A B : Matrix ι κ ℂ) :
    traceNorm (A * Bᴴ) ≤ Real.sqrt ((trace (A * Aᴴ)).re * (trace (B * Bᴴ)).re) := by
  obtain ⟨U, hU⟩ := exists_unitary_traceNorm (A * Bᴴ)
  rw [← hU, ← Matrix.mul_assoc]
  have h := re_trace_mul_conjTranspose_le ((U : Matrix ι ι ℂ) * A) B
  have heq : trace (((U : Matrix ι ι ℂ) * A) * ((U : Matrix ι ι ℂ) * A)ᴴ) =
      trace (A * Aᴴ) := by
    rw [Matrix.conjTranspose_mul, ← Matrix.mul_assoc, Matrix.mul_assoc (U : Matrix ι ι ℂ) A,
      trace_re_unitary_conjugate]
  rwa [heq] at h

end Frobenius

section PositiveBlock

universe v193_0 v193_1

variable {ι : Type v193_0} {κ : Type v193_1} [inst193_0 : Fintype ι] [inst193_1 : Fintype κ] [inst193_2 : DecidableEq ι] [inst193_3 : DecidableEq κ]

omit inst193_0 inst193_2 in
lemma sqrtRows_gram [Fintype ι] [DecidableEq ι] {R : Matrix κ κ ℂ} (hR : R.PosSemidef) (f g : ι → κ) :
    (CFC.sqrt R).submatrix f id * ((CFC.sqrt R).submatrix g id)ᴴ = R.submatrix f g := by
  rw [Matrix.conjTranspose_submatrix, (CFC.sqrt_nonneg R).posSemidef.isHermitian.eq,
    ← Matrix.submatrix_mul _ _ f id g Function.bijective_id,
    CFC.sqrt_mul_sqrt_self R hR.nonneg]

lemma traceNorm_submatrix_le {R : Matrix κ κ ℂ} (hR : R.PosSemidef) (f g : ι → κ) :
    traceNorm (R.submatrix f g) ≤
      Real.sqrt ((trace (R.submatrix f f)).re * (trace (R.submatrix g g)).re) := by
  have h := traceNorm_mul_conjTranspose_le ((CFC.sqrt R).submatrix f id)
    ((CFC.sqrt R).submatrix g id)
  simpa only [sqrtRows_gram hR] using h

theorem positive_block_estimate (H Z J : Matrix ι ι ℂ)
    (h : (Matrix.fromBlocks H Z Zᴴ J).PosSemidef) :
    traceNorm Z ≤ Real.sqrt ((trace H).re * (trace J).re) := by
  exact traceNorm_submatrix_le h Sum.inl Sum.inr

end PositiveBlock

section

def InClass {a b : ℕ} (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) : Prop :=
  Density R ∧ ∃ (c d : ℕ) (L : Mat c →ₗ[ℂ] Mat a) (M : Mat d →ₗ[ℂ] Mat b)
    (χ : Fin c × Fin d → ℂ), PPTType L ∧ PPTType M ∧ R = tensorMap L M (outer χ χ)

def weight {a b : ℕ} (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ)
    (X : Mat a) (Y : Mat b) : ℝ := (Matrix.trace ((X ⊗ₖ Y) * R)).re

lemma cp_positive {a b : ℕ} {L : Mat a →ₗ[ℂ] Mat b} (hL : CompletelyPositive L)
    {U : Mat a} (hU : U.PosSemidef) : (L U).PosSemidef := by
  have h := hL 1 (U.submatrix Prod.snd Prod.snd) (hU.submatrix Prod.snd)
  exact h.submatrix (fun i => (0,i))

section TensorBlocks

universe v344_0

def amplifyTensor {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d)
    {κ : Type v344_0} (U : Matrix (κ × (Fin a × Fin c)) (κ × (Fin a × Fin c)) ℂ) :
    Matrix (κ × (Fin b × Fin d)) (κ × (Fin b × Fin d)) ℂ :=
  fun i j => tensorMap L M (fun x y => U (i.1,x) (j.1,y)) i.2 j.2

universe v349_0

lemma tensorMap_amplify_positive {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    {M : Mat c →ₗ[ℂ] Mat d} (hL : CompletelyPositive L) (hM : CompletelyPositive M)
    {κ : Type v349_0} [Fintype κ]
    {U : Matrix (κ × (Fin a × Fin c)) (κ × (Fin a × Fin c)) ℂ} (hU : U.PosSemidef) :
    (amplifyTensor L M U).PosSemidef := by
  have h₁ := cp_amplifyIndex hM _
    (hU.submatrix (fun i : (κ × Fin a) × Fin c => (i.1.1, (i.1.2, i.2))))
  have h₂ := cp_amplifyIndex hL _
    (h₁.submatrix (fun i : (κ × Fin d) × Fin a => ((i.1.1, i.2), i.1.2)))
  have h₃ := h₂.submatrix (fun i : κ × (Fin b × Fin d) => ((i.1, i.2.2), i.2.1))
  convert h₃ using 1
  ext i j
  exact tensorMap_apply L M _ _ _ _ _

lemma tensorMap_global_transpose {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b)
    (M : Mat c →ₗ[ℂ] Mat d) (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) :
    tensorMap (L.comp (transposeLinear a)) (M.comp (transposeLinear c)) U =
    tensorMap L M Uᵀ := by
  ext i j
  calc
    _ = (L.comp (transposeLinear a))
        (fun x y => (M.comp (transposeLinear c)) (fun z w => U (x,z) (y,w)) i.2 j.2)
        i.1 j.1 := tensorMap_apply _ _ _ _ _ _ _
    _ = L (fun x y => M (fun z w => Uᵀ (x,z) (y,w)) i.2 j.2) i.1 j.1 := rfl
    _ = _ := (tensorMap_apply _ _ _ _ _ _ _).symm

universe v378_0

lemma outer_transpose_conj {ι : Type v378_0} (u s : ι → ℂ) :
    (outer (star s) (star u))ᵀ = outer u s := by
  ext i j
  simp [outer, Matrix.transpose_apply, mul_comm]

lemma tensorMap_outer_block {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    {M : Mat c →ₗ[ℂ] Mat d} (hL : CompletelyPositive L) (hM : CompletelyPositive M)
    (u s : Fin a × Fin c → ℂ) :
    (fromBlocks (tensorMap L M (outer u u)) (tensorMap L M (outer u s))
      (tensorMap L M (outer s u)) (tensorMap L M (outer s s))).PosSemidef := by
  let v : Bool × (Fin a × Fin c) → ℂ := fun i => if i.1 then s i.2 else u i.2
  have h := tensorMap_amplify_positive hL hM (outer_posSemidef v)
  have h' := h.submatrix (Sum.elim (fun i => (false,i)) (fun i => (true,i)))
  convert h' using 1
  ext i j
  cases i <;> cases j <;> simp [amplifyTensor, Matrix.submatrix, v, outer, Matrix.fromBlocks] <;> rfl

end TensorBlocks

universe v398_0

variable {ι : Type v398_0} [inst398_0 : Fintype ι] [inst398_1 : DecidableEq ι]

lemma filtered_block_estimate (H Z J F₀ F₁ : Matrix ι ι ℂ)
    (h : (fromBlocks H Z Zᴴ J).PosSemidef) :
    traceNorm (F₀ * Z * F₁ᴴ) ≤
      Real.sqrt ((trace (F₀ * H * F₀ᴴ)).re * (trace (F₁ * J * F₁ᴴ)).re) := by
  have hf := h.mul_mul_conjTranspose_same (fromBlocks F₀ 0 0 F₁)
  have hf' : (fromBlocks (F₀ * H * F₀ᴴ) (F₀ * Z * F₁ᴴ)
      (F₀ * Z * F₁ᴴ)ᴴ (F₁ * J * F₁ᴴ)).PosSemidef := by
    simpa [Matrix.fromBlocks_conjTranspose, Matrix.fromBlocks_multiply,
      Matrix.conjTranspose_mul, Matrix.mul_assoc] using hf
  exact positive_block_estimate _ _ _ hf'

lemma trace_sqrt_filter (D R : Matrix ι ι ℂ) (hD : D.PosSemidef) :
    trace (CFC.sqrt D * R * CFC.sqrt D) = trace (D * R) := by
  rw [Matrix.trace_mul_cycle, CFC.sqrt_mul_sqrt_self D hD.nonneg]

lemma sqrt_filtered_block_estimate (H Z J D₀ D₁ : Matrix ι ι ℂ)
    (h : (fromBlocks H Z Zᴴ J).PosSemidef) (hD₀ : D₀.PosSemidef) (hD₁ : D₁.PosSemidef) :
    traceNorm (CFC.sqrt D₀ * Z * CFC.sqrt D₁) ≤
      Real.sqrt ((trace (D₀ * H)).re * (trace (D₁ * J)).re) := by
  have hf := filtered_block_estimate H Z J (CFC.sqrt D₀) (CFC.sqrt D₁) h
  simpa only [(CFC.sqrt_nonneg D₀).posSemidef.isHermitian.eq,
    (CFC.sqrt_nonneg D₁).posSemidef.isHermitian.eq, trace_sqrt_filter D₀ H hD₀,
    trace_sqrt_filter D₁ J hD₁] using hf

end

section

lemma tensorMap_outer_block_adjoint {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    {M : Mat c →ₗ[ℂ] Mat d} (hL : CompletelyPositive L) (hM : CompletelyPositive M)
    (u s : Fin a × Fin c → ℂ) :
    (fromBlocks (tensorMap L M (outer u u)) (tensorMap L M (outer u s))
      (tensorMap L M (outer u s))ᴴ (tensorMap L M (outer s s))).PosSemidef := by
  have h := tensorMap_outer_block hL hM u s
  have he := (Matrix.isHermitian_fromBlocks_iff.mp h.isHermitian).2.1
  rwa [he]

lemma direct_block_bound {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    {M : Mat c →ₗ[ℂ] Mat d} (hL : CompletelyPositive L) (hM : CompletelyPositive M)
    (u s : Fin a × Fin c → ℂ) (D₀ D₁ : Matrix (Fin b × Fin d) (Fin b × Fin d) ℂ)
    (hD₀ : D₀.PosSemidef) (hD₁ : D₁.PosSemidef) :
    traceNorm (CFC.sqrt D₀ * tensorMap L M (outer u s) * CFC.sqrt D₁) ≤
      Real.sqrt ((trace (D₀ * tensorMap L M (outer u u))).re *
        (trace (D₁ * tensorMap L M (outer s s))).re) := by
  exact sqrt_filtered_block_estimate _ _ _ _ _
    (tensorMap_outer_block_adjoint hL hM u s) hD₀ hD₁

lemma reversed_block_bound {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    {M : Mat c →ₗ[ℂ] Mat d} (hL : PPTType L) (hM : PPTType M)
    (u s : Fin a × Fin c → ℂ) (D₀ D₁ : Matrix (Fin b × Fin d) (Fin b × Fin d) ℂ)
    (hD₀ : D₀.PosSemidef) (hD₁ : D₁.PosSemidef) :
    traceNorm (CFC.sqrt D₀ * tensorMap L M (outer u s) * CFC.sqrt D₁) ≤
      Real.sqrt ((trace (D₀ * tensorMap L M (outer s s))).re *
        (trace (D₁ * tensorMap L M (outer u u))).re) := by
  have h := direct_block_bound hL.2 hM.2 (star s) (star u) D₀ D₁ hD₀ hD₁
  simpa only [tensorMap_global_transpose, outer_transpose_conj] using h

universe v464_0

variable {ι : Type v464_0} [inst464_0 : Fintype ι] [inst464_1 : DecidableEq ι]

lemma trace_mul_nonneg {S T : Matrix ι ι ℂ}
    (hS : S.PosSemidef) (hT : T.PosSemidef) : 0 ≤ trace (S * T) := by
  let B := CFC.sqrt S
  have hB : Bᴴ = B := (CFC.sqrt_nonneg S).posSemidef.isHermitian.eq
  have hBB : B * B = S := CFC.sqrt_mul_sqrt_self S hS.nonneg
  have h := (hT.mul_mul_conjTranspose_same B).trace_nonneg
  rwa [hB, Matrix.trace_mul_cycle, hBB] at h

lemma psd_of_quadratic_nonneg (A : Matrix ι ι ℂ)
    (h : ∀ x : ι → ℂ, 0 ≤ star x ⬝ᵥ (A *ᵥ x)) : A.PosSemidef := by
  apply Matrix.posSemidef_iff_dotProduct_mulVec.mpr
  refine ⟨?_, h⟩
  apply Matrix.isSymmetric_toEuclideanLin_iff.mp
  rw [LinearMap.isSymmetric_iff_inner_map_self_real]
  intro x
  have hp : 0 ≤ inner ℂ x (A.toEuclideanLin x) := by
    simpa only [EuclideanSpace.inner_eq_star_dotProduct, Matrix.ofLp_toLpLin, Matrix.toLin'_apply, dotProduct_comm] using h (WithLp.ofLp x)
  have hs := (IsSelfAdjoint.of_nonneg hp).star_eq
  rw [← inner_conj_symm]
  simpa only [starRingEnd_apply, star_star] using hs.symm

omit inst464_1 in
lemma trace_mul_outer [DecidableEq ι] (A : Matrix ι ι ℂ) (u s : ι → ℂ) :
    trace (A * outer u s) = star s ⬝ᵥ (A *ᵥ u) := by
  simp only [trace, Matrix.diag, Matrix.mul_apply, outer, dotProduct, mulVec,
    Finset.mul_sum, Pi.star_apply]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro j _
  ring

def effectDual {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (X : Mat b) : Mat a :=
  fun i j => trace (X * L (matrixUnit j i))

lemma effectDual_pairing {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (X : Mat b) (U : Mat a) :
    trace (effectDual L X * U) = trace (X * L U) := by
  have he : trace (X * L U) = ∑ i, ∑ j, U i j * trace (X * L (matrixUnit i j)) := by
    rw [linearMap_matrix_units L U]
    simp only [Matrix.mul_sum, Matrix.mul_smul, Matrix.trace_sum, Matrix.trace_smul,
      smul_eq_mul]
  rw [he]
  simp only [trace, Matrix.diag, Matrix.mul_apply, effectDual]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro j _
  ring

lemma effectDual_positive {a b : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    (hL : CompletelyPositive L) {X : Mat b} (hX : X.PosSemidef) :
    (effectDual L X).PosSemidef := by
  apply psd_of_quadratic_nonneg
  intro u
  rw [← trace_mul_outer, effectDual_pairing]
  exact trace_mul_nonneg hX (cp_positive hL (outer_posSemidef u))

end

lemma tensorMap_add {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d)
    (U V : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) :
    tensorMap L M (U+V) = tensorMap L M U + tensorMap L M V := by
  ext i j
  simp [tensorMap, add_mul, Finset.sum_add_distrib]

lemma tensorMap_smul {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d)
    (z : ℂ) (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) :
    tensorMap L M (z • U) = z • tensorMap L M U := by
  ext i j
  simp [tensorMap, smul_eq_mul, mul_assoc, Finset.mul_sum]

lemma tensorMap_expansion {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b)
    (M : Mat c →ₗ[ℂ] Mat d) (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) :
    tensorMap L M U = ∑ i, ∑ j, U i j •
      (L (matrixUnit i.1 j.1) ⊗ₖ M (matrixUnit i.2 j.2)) := by
  ext s t
  simp only [Matrix.sum_apply, Matrix.smul_apply, smul_eq_mul, Matrix.kroneckerMap_apply,
    Fintype.sum_prod_type, tensorMap]
  apply Finset.sum_congr rfl
  intro i _
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro j _
  apply Finset.sum_congr rfl
  intro k _
  apply Finset.sum_congr rfl
  intro l _
  ring

lemma tensorMap_effect_pairing {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b)
    (M : Mat c →ₗ[ℂ] Mat d) (X : Mat b) (Y : Mat d)
    (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) :
    trace ((X ⊗ₖ Y) * tensorMap L M U) = trace ((effectDual L X ⊗ₖ effectDual M Y) * U) := by
  rw [tensorMap_expansion]
  simp only [Matrix.mul_sum, Matrix.mul_smul, Matrix.trace_sum, Matrix.trace_smul,
    ← Matrix.mul_kronecker_mul, Matrix.trace_kronecker, smul_eq_mul]
  simp only [trace, Matrix.diag, Matrix.mul_apply, Matrix.kroneckerMap_apply, effectDual]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro j _
  ring

lemma tensor_weight_nonneg {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b}
    {M : Mat c →ₗ[ℂ] Mat d} (hL : CompletelyPositive L) (hM : CompletelyPositive M)
    (u : Fin a × Fin c → ℂ) {X : Mat b} {Y : Mat d}
    (hX : X.PosSemidef) (hY : Y.PosSemidef) :
    0 ≤ weight (tensorMap L M (outer u u)) X Y := by
  exact re_trace_mul_nonneg (hX.kronecker hY) (tensorMap_positive hL hM (outer_posSemidef u))

section

universe v590_0

variable {ι : Type v590_0} [inst590_0 : Fintype ι] [inst590_1 : DecidableEq ι]

lemma matrix_cfc_continuous (f : ℝ → ℝ) (H : Matrix ι ι ℂ) :
    ContinuousOn f (spectrum ℝ H) := by
  rw [continuousOn_iff_continuous_domRestrict]
  exact continuous_of_discreteTopology

lemma matrix_cfc_mul (f g : ℝ → ℝ) (H : Matrix ι ι ℂ) (_hH : H.IsHermitian) :
    cfc (fun t => f t * g t) H = cfc f H * cfc g H := by
  exact cfc_mul f g H (matrix_cfc_continuous f H) (matrix_cfc_continuous g H)

lemma matrix_cfc_nonneg (f : ℝ → ℝ) (H : Matrix ι ι ℂ) (_hH : H.IsHermitian)
    (hf : ∀ t ∈ spectrum ℝ H, 0 ≤ f t) : 0 ≤ cfc f H := by
  exact cfc_nonneg (f := f) (a := H) hf

def whiteningFunction (t : ℝ) : ℝ := if t = 0 then 1 else (Real.sqrt t)⁻¹

def unwhiteningFunction (t : ℝ) : ℝ := if t = 0 then 1 else Real.sqrt t

def supportFunction (t : ℝ) : ℝ := if t = 0 then 0 else 1

lemma whitening_mul_unwhitening {t : ℝ} (ht : 0 ≤ t) :
    whiteningFunction t * unwhiteningFunction t = 1 := by
  by_cases h : t = 0
  · simp [whiteningFunction, unwhiteningFunction, h]
  · simp [whiteningFunction, unwhiteningFunction, h, Real.sqrt_ne_zero'.mpr (lt_of_le_of_ne ht (Ne.symm h))]

lemma whitening_square {t : ℝ} (ht : 0 ≤ t) :
    whiteningFunction t * t * whiteningFunction t = supportFunction t := by
  by_cases h : t = 0
  · simp [whiteningFunction, supportFunction, h]
  · have hs : Real.sqrt t ≠ 0 := Real.sqrt_ne_zero'.mpr (lt_of_le_of_ne ht (Ne.symm h))
    simp only [whiteningFunction, supportFunction, ite_eq_right h]
    calc
      _ = (Real.sqrt t)⁻¹ * (Real.sqrt t * Real.sqrt t) * (Real.sqrt t)⁻¹ := by rw [Real.mul_self_sqrt ht]
      _ = 1 := by field_simp

lemma whitening_of_psd (H : Matrix ι ι ℂ) (hH : H.PosSemidef) :
    let S := cfc whiteningFunction H
    let T := cfc unwhiteningFunction H
    let E := cfc supportFunction H
    S.IsHermitian ∧ T.IsHermitian ∧ S * T = 1 ∧ T * S = 1 ∧
      S * H * S = E ∧ IsStarProjection E := by
  dsimp
  have hh : IsSelfAdjoint H := hH.isHermitian
  have ht : ∀ t ∈ spectrum ℝ H, 0 ≤ t := fun t ht =>
    spectrum_nonneg_of_nonneg hH.nonneg ht
  have hST : cfc whiteningFunction H * cfc unwhiteningFunction H = 1 := by
    rw [← matrix_cfc_mul _ _ _ hH.isHermitian]
    have he : cfc (fun t => whiteningFunction t * unwhiteningFunction t) H = cfc (fun _ : ℝ => 1) H := by
      apply cfc_congr
      intro t ht'
      exact whitening_mul_unwhitening (ht t ht')
    rw [he, cfc_const_one ℝ H]
  refine ⟨IsSelfAdjoint.cfc.isHermitian, IsSelfAdjoint.cfc.isHermitian, hST,
    ?_, ?_, ?_⟩
  · rw [(cfc_commute_cfc unwhiteningFunction whiteningFunction H).eq, hST]
  · calc
      _ = cfc whiteningFunction H * cfc (id : ℝ → ℝ) H * cfc whiteningFunction H := by rw [cfc_id ℝ H]
      _ = cfc (fun t => whiteningFunction t * t * whiteningFunction t) H := by
        rw [matrix_cfc_mul _ _ H hH.isHermitian, matrix_cfc_mul _ _ H hH.isHermitian]
        rfl
      _ = _ := cfc_congr (fun t ht' => whitening_square (ht t ht'))
  · constructor
    · change cfc supportFunction H * cfc supportFunction H = cfc supportFunction H
      rw [← matrix_cfc_mul _ _ _ hH.isHermitian]
      apply cfc_congr
      intro t _
      simp [supportFunction]
    · exact IsSelfAdjoint.cfc

end

section

universe v667_0

variable {ι : Type v667_0} [inst667_0 : Fintype ι] [inst667_1 : DecidableEq ι]

def cutFunction (t : ℝ) : ℝ := if 0 ≤ t then 1 else 0

lemma spectral_cut (H : Matrix ι ι ℂ) (hH : H.IsHermitian) :
    let P := cfc cutFunction H
    IsStarProjection P ∧ Commute P H ∧ (P * H * P).PosSemidef ∧
      ((1-P) * (-H) * (1-P)).PosSemidef := by
  dsimp
  have hh : IsSelfAdjoint H := hH
  have hp : IsStarProjection (cfc cutFunction H) := by
    constructor
    · change cfc cutFunction H * cfc cutFunction H = cfc cutFunction H
      rw [← matrix_cfc_mul _ _ H hH]
      apply cfc_congr
      intro t _
      simp [cutFunction]
    · exact IsSelfAdjoint.cfc
  have hc : Commute (cfc cutFunction H) H := (Commute.refl H).cfc_real _
  have hq : 1 - cfc cutFunction H = cfc (fun t => 1 - cutFunction t) H := by
    rw [cfc_sub _ _ H (matrix_cfc_continuous _ H) (matrix_cfc_continuous _ H), cfc_const_one ℝ H]
  refine ⟨hp, hc, ?_, ?_⟩
  · have he : cfc cutFunction H * H * cfc cutFunction H =
        cfc (fun t => cutFunction t * t * cutFunction t) H := by
      conv_lhs => arg 1; arg 2; rw [← cfc_id ℝ H]
      rw [matrix_cfc_mul _ _ H hH, matrix_cfc_mul _ _ H hH]
      rfl
    rw [he]
    apply LE.le.posSemidef
    apply matrix_cfc_nonneg _ _ hH
    intro t _
    by_cases ht : 0 ≤ t <;> simp [cutFunction, ht]
  · rw [hq]
    have hn : -H = cfc (fun t : ℝ => -t) H := by rw [cfc_neg_id (R := ℝ) H]
    have he : cfc (fun t => 1 - cutFunction t) H * (-H) * cfc (fun t => 1 - cutFunction t) H =
        cfc (fun t => (1-cutFunction t) * (-t) * (1-cutFunction t)) H := by
      conv_lhs => arg 1; arg 2; rw [hn]
      rw [matrix_cfc_mul _ _ H hH, matrix_cfc_mul _ _ H hH]
    rw [he]
    apply LE.le.posSemidef
    apply matrix_cfc_nonneg _ _ hH
    intro t _
    by_cases ht : 0 ≤ t <;> simp [cutFunction, ht]
    linarith

open scoped Matrix.Norms.L2Operator in
lemma commute_of_sum_projection (A B E : Matrix ι ι ℂ)
    (hA : A.PosSemidef) (hB : B.PosSemidef) (hE : IsStarProjection E) (hsum : A+B=E) :
    Commute A B := by
  have hle : A ≤ E := by rw [← hsum]; exact le_add_of_nonneg_right hB.nonneg
  have hsupp := hE.mul_right_and_mul_left_of_nonneg_of_le hA.nonneg hle
  have he : B = E - A := by rw [← hsum]; abel
  change A * B = B * A
  rw [he, mul_sub, sub_mul, hsupp.1, hsupp.2]

lemma whitened_effects_commute (A B : Matrix ι ι ℂ) (hA : A.PosSemidef) (hB : B.PosSemidef) :
    let S := cfc whiteningFunction (A+B)
    (S * A * S).PosSemidef ∧ (S * B * S).PosSemidef ∧
      Commute (S * A * S) (S * B * S) := by
  dsimp
  let S := cfc whiteningFunction (A+B)
  let E := cfc supportFunction (A+B)
  have hw := whitening_of_psd (A+B) (hA.add hB)
  dsimp at hw
  have hS : Sᴴ = S := hw.1.eq
  have hSA : (S * A * S).PosSemidef := by
    simpa only [hS] using hA.mul_mul_conjTranspose_same S
  have hSB : (S * B * S).PosSemidef := by
    simpa only [hS] using hB.mul_mul_conjTranspose_same S
  have hsum : S * A * S + S * B * S = E := by
    rw [← add_mul, ← mul_add]
    exact hw.2.2.2.2.1
  exact ⟨hSA, hSB, commute_of_sum_projection _ _ E hSA hSB hw.2.2.2.2.2 hsum⟩

end

section

universe v746_0

variable {ι : Type v746_0} [inst746_0 : Fintype ι] [inst746_1 : DecidableEq ι]

lemma projection_cross_zero {P A : Matrix ι ι ℂ}
    (hP : IsStarProjection P) (hPA : Commute P A) : P * A * (1-P) = 0 := by
  rw [hPA.eq, mul_assoc, hP.mul_one_sub_self, mul_zero]

lemma commuting_spectral_cut (A B : Matrix ι ι ℂ) (hA : A.IsHermitian)
    (hB : B.IsHermitian) (hAB : Commute A B) :
    ∃ P : Matrix ι ι ℂ, IsStarProjection P ∧ Commute P A ∧ Commute P B ∧
      (P * (A-B) * P).PosSemidef ∧ ((1-P) * (B-A) * (1-P)).PosSemidef := by
  let P := cfc cutFunction (A-B)
  have h := spectral_cut (A-B) (hA.sub hB)
  have ha : Commute (A-B) A := (Commute.refl A).sub_left hAB.symm
  have hb : Commute (A-B) B := hAB.sub_left (Commute.refl B)
  refine ⟨P, h.1, ha.cfc_real _, hb.cfc_real _, h.2.2.1, ?_⟩
  simpa only [neg_sub] using h.2.2.2

lemma congruence_cross (S T P A : Matrix ι ι ℂ)
    (hS : S.IsHermitian) (hT : T.IsHermitian) (hP : P.IsHermitian) :
    (S * P * T)ᴴ * A * (S * (1-P) * T) = T * (P * (S*A*S) * (1-P)) * T := by
  simp only [Matrix.conjTranspose_mul, hS.eq, hT.eq, hP.eq]
  noncomm_ring

omit inst746_1 in
lemma congruence_diagonal [DecidableEq ι] (S T P A : Matrix ι ι ℂ)
    (hS : S.IsHermitian) (hT : T.IsHermitian) (hP : P.IsHermitian) :
    (S * P * T)ᴴ * A * (S * P * T) = T * (P * (S*A*S) * P) * T := by
  simp only [Matrix.conjTranspose_mul, hS.eq, hT.eq, hP.eq]
  noncomm_ring

lemma generalized_effect_split (A B : Matrix ι ι ℂ) (hA : A.PosSemidef)
    (hB : B.PosSemidef) :
    ∃ V W : Matrix ι ι ℂ, V + W = 1 ∧ Vᴴ * A * W = 0 ∧ Vᴴ * B * W = 0 ∧
      (Vᴴ * (A-B) * V).PosSemidef ∧ (Wᴴ * (B-A) * W).PosSemidef := by
  let S := cfc whiteningFunction (A+B)
  let T := cfc unwhiteningFunction (A+B)
  have hw := whitening_of_psd (A+B) (hA.add hB)
  have hS : S.IsHermitian := hw.1
  have hT : T.IsHermitian := hw.2.1
  have hST : S*T=1 := hw.2.2.1
  have hc := whitened_effects_commute A B hA hB
  obtain ⟨P, hP, hpA, hpB, hpplus, hpminus⟩ :=
    commuting_spectral_cut (S*A*S) (S*B*S) hc.1.isHermitian hc.2.1.isHermitian hc.2.2
  have hP' : P.IsHermitian := hP.isSelfAdjoint
  have hQ : (1-P).IsHermitian := Matrix.isHermitian_one.sub hP'
  refine ⟨S*P*T, S*(1-P)*T, ?_, ?_, ?_, ?_, ?_⟩
  · calc
      _ = S * (P + (1-P)) * T := by noncomm_ring
      _ = 1 := by simp [hST]
  · rw [congruence_cross S T P A hS hT hP', projection_cross_zero hP hpA, mul_zero, zero_mul]
  · rw [congruence_cross S T P B hS hT hP', projection_cross_zero hP hpB, mul_zero, zero_mul]
  · rw [congruence_diagonal S T P (A-B) hS hT hP']
    have he : S * (A-B) * S = S*A*S - S*B*S := by noncomm_ring
    rw [he]
    simpa only [hT.eq] using hpplus.mul_mul_conjTranspose_same T
  · rw [congruence_diagonal S T (1-P) (B-A) hS hT hQ]
    have he : S * (B-A) * S = S*B*S - S*A*S := by noncomm_ring
    rw [he]
    simpa only [hT.eq] using hpminus.mul_mul_conjTranspose_same T

end

section

universe v812_0

variable {ι : Type v812_0} [inst812_0 : Fintype ι] [inst812_1 : DecidableEq ι]

def qform (A : Matrix ι ι ℂ) (u : ι → ℂ) : ℝ := (star u ⬝ᵥ (A *ᵥ u)).re

omit inst812_1 in
lemma qform_nonneg [DecidableEq ι] {A : Matrix ι ι ℂ} (hA : A.PosSemidef) (u : ι → ℂ) :
    0 ≤ qform A u := by
  exact (hA.dotProduct_mulVec_nonneg u).1

omit inst812_1 in
lemma qform_congruence [DecidableEq ι] (A T : Matrix ι ι ℂ) (u : ι → ℂ) :
    qform A (T *ᵥ u) = qform (Tᴴ * A * T) u := by
  simp only [qform, Matrix.star_mulVec, Matrix.mulVec_mulVec, Matrix.dotProduct_mulVec,
    Matrix.vecMul_vecMul, mul_assoc]

omit inst812_1 in
lemma qform_add [DecidableEq ι] (A B : Matrix ι ι ℂ) (u : ι → ℂ) :
    qform (A+B) u = qform A u + qform B u := by
  simp [qform, Matrix.add_mulVec, dotProduct_add]

omit inst812_1 in
lemma qform_sub [DecidableEq ι] (A B : Matrix ι ι ℂ) (u : ι → ℂ) :
    qform (A-B) u = qform A u - qform B u := by
  simp [qform, Matrix.sub_mulVec, dotProduct_sub]

lemma tensor_qform_eq_weight {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b)
    (M : Mat c →ₗ[ℂ] Mat d) (X : Mat b) (Y : Mat d) (u : Fin a × Fin c → ℂ) :
    weight (tensorMap L M (outer u u)) X Y = qform (effectDual L X ⊗ₖ effectDual M Y) u := by
  rw [weight, tensorMap_effect_pairing, trace_mul_outer]
  rfl

lemma tensor_filter_congruence {a c : ℕ} (A V W : Mat a) (B : Mat c) :
    (V ⊗ₖ (1 : Mat c))ᴴ * (A ⊗ₖ B) * (W ⊗ₖ (1 : Mat c)) =
      (Vᴴ * A * W) ⊗ₖ B := by
  simp only [Matrix.conjTranspose_kronecker, Matrix.conjTranspose_one,
    ← Matrix.mul_kronecker_mul, one_mul, mul_one]

lemma filter_qform_split {A V W : Matrix ι ι ℂ} (hVW : V+W=1)
    (hA : A.IsHermitian) (hcross : Vᴴ * A * W=0) (u : ι → ℂ) :
    qform A u = qform A (V *ᵥ u) + qform A (W *ᵥ u) := by
  have hcross' : Wᴴ * A * V=0 := by
    have h := congrArg Matrix.conjTranspose hcross
    simpa only [Matrix.conjTranspose_mul, Matrix.conjTranspose_conjTranspose,
      hA.eq, Matrix.conjTranspose_zero, mul_assoc] using h
  have he : A = Vᴴ*A*V + Wᴴ*A*W := by
    calc
      A = (V+W)ᴴ*A*(V+W) := by simp [hVW]
      _ = Vᴴ*A*V + Wᴴ*A*W := by
        simp only [Matrix.conjTranspose_add, add_mul, mul_add, hcross, hcross']
        abel
  rw [qform_congruence, qform_congruence, ← qform_add, ← he]

lemma input_split_weights {a c : ℕ} (A₀ A₁ : Mat a) (B₀ B₁ : Mat c)
    (hA₀ : A₀.PosSemidef) (hA₁ : A₁.PosSemidef)
    (hB₀ : B₀.PosSemidef) (hB₁ : B₁.PosSemidef) (χ : Fin a × Fin c → ℂ) :
    ∃ v w, χ = v+w ∧
      (∀ A ∈ ({A₀,A₁} : Finset (Mat a)), ∀ B ∈ ({B₀,B₁} : Finset (Mat c)),
        qform (A ⊗ₖ B) χ = qform (A ⊗ₖ B) v + qform (A ⊗ₖ B) w) ∧
      qform (A₁ ⊗ₖ B₁) v ≤ qform (A₀ ⊗ₖ B₁) v ∧
      qform (A₀ ⊗ₖ B₀) w ≤ qform (A₁ ⊗ₖ B₀) w := by
  classical
  obtain ⟨V,W,hVW,hcross₀,hcross₁,hplus,hminus⟩ := generalized_effect_split A₀ A₁ hA₀ hA₁
  let VV := V ⊗ₖ (1 : Mat c)
  let WW := W ⊗ₖ (1 : Mat c)
  have hVVWW : VV+WW=1 := by
    dsimp [VV, WW]
    rw [← Matrix.add_kronecker, hVW, Matrix.one_kronecker_one]
  refine ⟨VV *ᵥ χ, WW *ᵥ χ, ?_, ?_, ?_, ?_⟩
  · rw [← Matrix.add_mulVec, hVVWW, Matrix.one_mulVec]
  · intro A hA B hB
    have hc : Vᴴ*A*W=0 := by
      simp only [Finset.mem_insert, Finset.mem_singleton] at hA
      rcases hA with rfl | rfl <;> assumption
    have hAp : A.PosSemidef := by
      simp only [Finset.mem_insert, Finset.mem_singleton] at hA
      rcases hA with rfl | rfl <;> assumption
    have hBp : B.PosSemidef := by
      simp only [Finset.mem_insert, Finset.mem_singleton] at hB
      rcases hB with rfl | rfl <;> assumption
    apply filter_qform_split hVVWW (hAp.kronecker hBp).isHermitian
    dsimp [VV, WW]
    rw [tensor_filter_congruence, hc, Matrix.zero_kronecker]
  · have h := qform_nonneg (hplus.kronecker hB₁) χ
    rw [qform_congruence, qform_congruence]
    dsimp [VV]
    rw [tensor_filter_congruence, tensor_filter_congruence]
    have he : (Vᴴ * (A₀-A₁) * V) ⊗ₖ B₁ =
        (Vᴴ*A₀*V) ⊗ₖ B₁ - (Vᴴ*A₁*V) ⊗ₖ B₁ := by
      rw [mul_sub, sub_mul]
      ext i j
      simp only [Matrix.kroneckerMap_apply, Matrix.sub_apply, sub_mul]
    rw [he, qform_sub] at h
    linarith
  · have h := qform_nonneg (hminus.kronecker hB₀) χ
    rw [qform_congruence, qform_congruence]
    dsimp [WW]
    rw [tensor_filter_congruence, tensor_filter_congruence]
    have he : (Wᴴ * (A₁-A₀) * W) ⊗ₖ B₀ =
        (Wᴴ*A₁*W) ⊗ₖ B₀ - (Wᴴ*A₀*W) ⊗ₖ B₀ := by
      rw [mul_sub, sub_mul]
      ext i j
      simp only [Matrix.kroneckerMap_apply, Matrix.sub_apply, sub_mul]
    rw [he, qform_sub] at h
    linarith

end

universe v919_0

lemma outer_add_four {ι : Type v919_0} (v w : ι → ℂ) :
    outer (v+w) (v+w) = outer v v + outer w w + outer v w + outer w v := by
  ext i j
  simp only [outer, Pi.add_apply, star_add, Matrix.add_apply]
  ring

lemma sqrt_mul_mono {a b c d : ℝ} (hb : 0 ≤ b) (hc : 0 ≤ c)
    (hac : a ≤ c) (hbd : b ≤ d) : Real.sqrt (a*b) ≤ Real.sqrt (c*d) :=
  Real.sqrt_le_sqrt (mul_le_mul hac hbd hb hc)

theorem four_effect_inequality {a b : ℕ}
    (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : InClass R)
    (X₀ X₁ : Mat a) (Y₀ Y₁ : Mat b)
    (hX₀ : X₀.PosSemidef) (hX₁ : X₁.PosSemidef)
    (hY₀ : Y₀.PosSemidef) (hY₁ : Y₁.PosSemidef) :
    traceNorm (CFC.sqrt (X₀ ⊗ₖ Y₀) * R * CFC.sqrt (X₁ ⊗ₖ Y₁)) ≤
      Real.sqrt (weight R X₀ Y₀ * weight R X₀ Y₁) +
      Real.sqrt (weight R X₁ Y₀ * weight R X₁ Y₁) +
      2 * Real.sqrt (weight R X₀ Y₁ * weight R X₁ Y₀) := by
  classical
  obtain ⟨_,c,d,L,M,χ,hL,hM,rfl⟩ := hR
  let A₀ := effectDual L X₀
  let A₁ := effectDual L X₁
  let B₀ := effectDual M Y₀
  let B₁ := effectDual M Y₁
  obtain ⟨v,w,hχ,hsplit,hv,hw⟩ := input_split_weights A₀ A₁ B₀ B₁
    (effectDual_positive hL.1 hX₀) (effectDual_positive hL.1 hX₁)
    (effectDual_positive hM.1 hY₀) (effectDual_positive hM.1 hY₁) χ
  let p := fun X Y u => weight (tensorMap L M (outer u u)) X Y
  let Z := fun u s => CFC.sqrt (X₀ ⊗ₖ Y₀) * tensorMap L M (outer u s) *
    CFC.sqrt (X₁ ⊗ₖ Y₁)
  have hpos (X : Mat a) (Y : Mat b) (hX : X.PosSemidef) (hY : Y.PosSemidef)
      (u : Fin c × Fin d → ℂ) : 0 ≤ p X Y u := tensor_weight_nonneg hL.1 hM.1 u hX hY
  have hsplit' (X : Mat a) (hX : X ∈ ({X₀,X₁} : Finset (Mat a)))
      (Y : Mat b) (hY : Y ∈ ({Y₀,Y₁} : Finset (Mat b))) :
      p X Y χ = p X Y v + p X Y w := by
    dsimp [p]
    simp only [tensor_qform_eq_weight]
    apply hsplit
    · simp only [Finset.mem_insert, Finset.mem_singleton] at hX ⊢
      rcases hX with rfl | rfl <;> tauto
    · simp only [Finset.mem_insert, Finset.mem_singleton] at hY ⊢
      rcases hY with rfl | rfl <;> tauto
  have hmono (X : Mat a) (hX : X ∈ ({X₀,X₁} : Finset (Mat a)))
      (Y : Mat b) (hY : Y ∈ ({Y₀,Y₁} : Finset (Mat b))) :
      p X Y v ≤ p X Y χ ∧ p X Y w ≤ p X Y χ := by
    have hXp : X.PosSemidef := by
      simp only [Finset.mem_insert, Finset.mem_singleton] at hX
      rcases hX with rfl | rfl <;> assumption
    have hYp : Y.PosSemidef := by
      simp only [Finset.mem_insert, Finset.mem_singleton] at hY
      rcases hY with rfl | rfl <;> assumption
    have he := hsplit' X hX Y hY
    have hvp := hpos X Y hXp hYp v
    have hwp := hpos X Y hXp hYp w
    constructor <;> linarith
  have h00 := hmono X₀ (by simp) Y₀ (by simp)
  have h01 := hmono X₀ (by simp) Y₁ (by simp)
  have h10 := hmono X₁ (by simp) Y₀ (by simp)
  have h11 := hmono X₁ (by simp) Y₁ (by simp)
  have hv' : p X₁ Y₁ v ≤ p X₀ Y₁ v := by simpa [p, tensor_qform_eq_weight, A₀,A₁,B₀,B₁] using hv
  have hw' : p X₀ Y₀ w ≤ p X₁ Y₀ w := by simpa [p, tensor_qform_eq_weight, A₀,A₁,B₀,B₁] using hw
  have hdir (u s : Fin c × Fin d → ℂ) :
      traceNorm (Z u s) ≤ Real.sqrt (p X₀ Y₀ u * p X₁ Y₁ s) :=
    direct_block_bound hL.1 hM.1 u s _ _ (hX₀.kronecker hY₀) (hX₁.kronecker hY₁)
  have hrev (u s : Fin c × Fin d → ℂ) :
      traceNorm (Z u s) ≤ Real.sqrt (p X₀ Y₀ s * p X₁ Y₁ u) :=
    reversed_block_bound hL hM u s _ _ (hX₀.kronecker hY₀) (hX₁.kronecker hY₁)
  have hvv : traceNorm (Z v v) ≤ Real.sqrt (p X₀ Y₀ χ * p X₀ Y₁ χ) :=
    (hdir v v).trans (sqrt_mul_mono (hpos _ _ hX₁ hY₁ v) (hpos _ _ hX₀ hY₀ χ)
      h00.1 (hv'.trans h01.1))
  have hww : traceNorm (Z w w) ≤ Real.sqrt (p X₁ Y₀ χ * p X₁ Y₁ χ) :=
    (hdir w w).trans (sqrt_mul_mono (hpos _ _ hX₁ hY₁ w) (hpos _ _ hX₁ hY₀ χ)
      (hw'.trans h10.2) h11.2)
  have hcross : Real.sqrt (p X₀ Y₀ w * p X₁ Y₁ v) ≤
      Real.sqrt (p X₀ Y₁ χ * p X₁ Y₀ χ) := by
    rw [mul_comm (p X₀ Y₁ χ)]
    exact sqrt_mul_mono (hpos _ _ hX₁ hY₁ v) (hpos _ _ hX₁ hY₀ χ)
      (hw'.trans h10.2) (hv'.trans h01.1)
  have hvw := (hrev v w).trans hcross
  have hwv := (hdir w v).trans hcross
  have hZ : Z χ χ = Z v v + Z w w + Z v w + Z w v := by
    dsimp [Z]
    rw [hχ, outer_add_four]
    simp only [tensorMap_add, mul_add, add_mul]
  change traceNorm (Z χ χ) ≤ _
  rw [hZ]
  have ht₁ := traceNorm_add_le (Z v v) (Z w w)
  have ht₂ := traceNorm_add_le (Z v v + Z w w) (Z v w)
  have ht₃ := traceNorm_add_le (Z v v + Z w w + Z v w) (Z w v)
  change traceNorm _ ≤ Real.sqrt (p X₀ Y₀ χ * p X₀ Y₁ χ) +
    Real.sqrt (p X₁ Y₀ χ * p X₁ Y₁ χ) + 2 * Real.sqrt (p X₀ Y₁ χ * p X₁ Y₀ χ)
  linarith

universe v1039_0

lemma cp_sum {a b : ℕ} {ν : Type v1039_0} [Fintype ν] (L : ν → Mat a →ₗ[ℂ] Mat b)
    (hL : ∀ s, CompletelyPositive (L s)) : CompletelyPositive (∑ s, L s) := by
  intro r U hU
  have he : amplify (∑ s, L s) r U = ∑ s, amplify (L s) r U := by
    ext i j
    change (∑ s, L s) (fun x y => U (i.1,x) (j.1,y)) i.2 j.2 = _
    erw [LinearMap.sum_apply]
    simp only [Matrix.sum_apply, amplify]

  rw [he]
  exact Matrix.posSemidef_sum _ (fun s _ => hL s r U hU)

lemma cp_comp {a b c : ℕ} {L : Mat b →ₗ[ℂ] Mat c} {M : Mat a →ₗ[ℂ] Mat b}
    (hL : CompletelyPositive L) (hM : CompletelyPositive M) : CompletelyPositive (L.comp M) := by
  intro r U hU
  exact hL r (amplify M r U) (hM r U hU)

def tensorLinear {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) :
    Mat (a*c) →ₗ[ℂ] Mat (b*d) where
  toFun U := (tensorMap L M (U.submatrix finProdFinEquiv finProdFinEquiv)).submatrix
    finProdFinEquiv.symm finProdFinEquiv.symm
  map_add' U V := by
    simp only [Matrix.submatrix_add, Pi.add_apply, tensorMap_add]
  map_smul' z U := by
    simp only [Matrix.submatrix_smul, Pi.smul_apply, tensorMap_smul, RingHom.id_apply]

lemma cp_tensorLinear {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b} {M : Mat c →ₗ[ℂ] Mat d}
    (hL : CompletelyPositive L) (hM : CompletelyPositive M) : CompletelyPositive (tensorLinear L M) := by
  intro r U hU
  have h := (tensorMap_amplify_positive hL hM
    (hU.submatrix (fun i : Fin r × (Fin a × Fin c) => (i.1, finProdFinEquiv i.2)))).submatrix
      (fun i : Fin r × Fin (b*d) => (i.1, finProdFinEquiv.symm i.2))
  exact h

lemma tensorLinear_transpose {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) :
    (tensorLinear L M).comp (transposeLinear (a*c)) =
      tensorLinear (L.comp (transposeLinear a)) (M.comp (transposeLinear c)) := by
  ext U i j
  exact congr_fun (congr_fun (tensorMap_global_transpose L M
    (U.submatrix finProdFinEquiv finProdFinEquiv)).symm
      (finProdFinEquiv.symm i)) (finProdFinEquiv.symm j)

lemma ppt_tensorLinear {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b} {M : Mat c →ₗ[ℂ] Mat d}
    (hL : PPTType L) (hM : PPTType M) : PPTType (tensorLinear L M) := by
  refine ⟨cp_tensorLinear hL.1 hM.1, ?_⟩
  rw [tensorLinear_transpose]
  exact cp_tensorLinear hL.2 hM.2

end ZeroKey

end

end OAI