import OAI.Probability.EntangledGames.HilbertSchmidt

namespace OAI

universe u_n u_ι

open scoped BigOperators ComplexOrder
open scoped MatrixOrder
open Matrix
open MeasureTheory Filter Set
open scoped Topology
open scoped Matrix.Norms.Elementwise

noncomputable section
open MeasureTheory Set
open scoped Interval

namespace ThresholdParallelRepetition.QuantumSampling

lemma floor_shift_monotone (u : ℝ) : Monotone (fun s : ℝ => (⌊u+s⌋ : ℝ)) := by
  intro s t h
  change (⌊u+s⌋ : ℝ) ≤ (⌊u+t⌋ : ℝ)
  exact_mod_cast Int.floor_mono (show u+s ≤ u+t by linarith)

lemma integral_floor_shift (u : ℝ) : (∫ s in (0:ℝ)..1, (⌊u+s⌋ : ℝ)) = u := by
  let c := 1 - Int.fract u
  have hc0 : 0 ≤ c := by dsimp [c]; linarith [Int.fract_lt_one u]
  have hc1 : c ≤ 1 := by dsimp [c]; linarith [Int.fract_nonneg u]
  have hu : Int.fract u + (⌊u⌋ : ℝ) = u := Int.fract_add_floor u
  have hleft : (∫ s in (0:ℝ)..c, (⌊u+s⌋ : ℝ)) = c * (⌊u⌋ : ℝ) := by
    calc
      _ = ∫ _ in (0:ℝ)..c, (⌊u⌋ : ℝ) := by
        apply intervalIntegral.integral_congr_Ioo_of_le hc0
        intro s hs
        dsimp only
        have he : ⌊u+s⌋ = ⌊u⌋ := Int.floor_eq_iff.mpr ⟨by linarith [Int.fract_nonneg u, hs.1], by dsimp [c] at hs; linarith [hs.2]⟩
        rw [he]
      _ = _ := by simp
  have hright : (∫ s in c..(1:ℝ), (⌊u+s⌋ : ℝ)) = (1-c) * ((⌊u⌋ : ℝ)+1) := by
    calc
      _ = ∫ _ in c..(1:ℝ), ((⌊u⌋ : ℝ)+1) := by
        apply intervalIntegral.integral_congr_Ioo_of_le hc1
        intro s hs
        dsimp only
        have he : ⌊u+s⌋ = ⌊u⌋ + 1 := Int.floor_eq_iff.mpr ⟨by push_cast; dsimp [c] at hs; linarith [hs.1], by push_cast; linarith [Int.fract_lt_one u, hs.2]⟩
        rw [he]; push_cast; rfl
      _ = _ := by simp; ring
  rw [← intervalIntegral.integral_add_adjacent_intervals
    ((floor_shift_monotone u).intervalIntegrable (μ := volume) (a := 0) (b := c))
    ((floor_shift_monotone u).intervalIntegrable (μ := volume) (a := c) (b := 1)), hleft, hright]
  dsimp [c]
  nlinarith

def separated (u v s : ℝ) : ℝ := if ⌊u+s⌋ = ⌊v+s⌋ then 0 else 1

lemma separated_nonneg (u v s : ℝ) : 0 ≤ separated u v s := by unfold separated; split <;> norm_num
lemma separated_le_one (u v s : ℝ) : separated u v s ≤ 1 := by unfold separated; split <;> norm_num
lemma separated_symm (u v s : ℝ) : separated u v s = separated v u s := by simp [separated, eq_comm]

lemma separated_measurable (u v : ℝ) : Measurable (separated u v) := by
  unfold separated
  exact measurable_const.ite (measurableSet_eq_fun ((measurable_const.add measurable_id).floor)
    ((measurable_const.add measurable_id).floor)) measurable_const

lemma separated_integrable (u v a b : ℝ) : IntervalIntegrable (separated u v) volume a b := by
  apply (intervalIntegrable_const (c := (1:ℝ))).mono_fun' (separated_measurable u v).aestronglyMeasurable
  exact Filter.Eventually.of_forall fun s => by dsimp only; rw [Real.norm_eq_abs, abs_of_nonneg (separated_nonneg u v s)]; exact separated_le_one u v s

lemma separated_le_floor_sub {u v : ℝ} (huv : u ≤ v) (s : ℝ) :
    separated u v s ≤ (⌊v+s⌋ : ℝ) - (⌊u+s⌋ : ℝ) := by
  unfold separated
  split_ifs with h
  · rw [h]; simp
  · have hle : ⌊u+s⌋ ≤ ⌊v+s⌋ := Int.floor_mono (by linarith)
    have hlt : ⌊u+s⌋ + 1 ≤ ⌊v+s⌋ := by omega
    exact_mod_cast (show (1:ℤ) ≤ ⌊v+s⌋ - ⌊u+s⌋ by omega)

lemma integral_separated_le {u v : ℝ} :
    (∫ s in (0:ℝ)..1, separated u v s) ≤ |u-v| := by
  wlog huv : u ≤ v generalizing u v
  · rw [show separated u v = separated v u by funext s; exact separated_symm _ _ _]
    simpa only [abs_sub_comm] using this (le_of_not_ge huv)
  calc
    _ ≤ ∫ s in (0:ℝ)..1, ((⌊v+s⌋ : ℝ) - (⌊u+s⌋ : ℝ)) := by
      apply intervalIntegral.integral_mono_on (by norm_num) (separated_integrable _ _ _ _)
        (((floor_shift_monotone v).intervalIntegrable).sub ((floor_shift_monotone u).intervalIntegrable))
      intro s _
      exact separated_le_floor_sub huv s
    _ = v-u := by rw [intervalIntegral.integral_sub
      ((floor_shift_monotone v).intervalIntegrable) ((floor_shift_monotone u).intervalIntegrable),
      integral_floor_shift, integral_floor_shift]
    _ = |u-v| := by rw [abs_of_nonpos (by linarith)]; ring

def binEnvelope (a b ε s : ℝ) : ℝ :=
  (a-b)^2 + 2*a*b*separated (Real.log a/ε) (Real.log b/ε) s

lemma binEnvelope_nonneg {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (ε s : ℝ) :
    0 ≤ binEnvelope a b ε s := by
  unfold binEnvelope
  exact add_nonneg (sq_nonneg _) (mul_nonneg (by positivity) (separated_nonneg _ _ _))

lemma binEnvelope_integrable (a b ε l r : ℝ) :
    IntervalIntegrable (binEnvelope a b ε) volume l r := by
  exact intervalIntegrable_const.add ((separated_integrable _ _ _ _).const_mul _)

lemma log_difference_bound {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) :
    a * (Real.log b - Real.log a) ≤ b-a := by
  have hb : 0 < b := lt_of_lt_of_le ha hab
  have h := Real.log_le_sub_one_of_pos (div_pos hb ha)
  rw [Real.log_div hb.ne' ha.ne'] at h
  have hh := mul_le_mul_of_nonneg_left h ha.le
  calc
    _ ≤ a*(b/a-1) := hh
    _ = b-a := by field_simp

lemma logarithmic_envelope_bound {a b ε : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b)
    (hε : 0 < ε) (hε1 : ε ≤ 1) :
    (a-b)^2 + 2*a*b*(|Real.log a-Real.log b|/ε) ≤ 3/ε * |a-b| * (a+b) := by
  wlog hab : a ≤ b generalizing a b
  · have hh := this hb ha (le_of_not_ge hab)
    simpa only [abs_sub_comm b a, abs_sub_comm (Real.log b) (Real.log a),
      add_comm b a, sub_sq_comm b a, mul_right_comm (2:ℝ) b a] using hh
  rw [abs_of_nonpos (sub_nonpos.mpr hab)]
  by_cases ha0 : a = 0
  · subst a
    simp only [zero_sub, neg_neg, zero_mul, mul_zero, zero_add, neg_sq, add_zero]
    apply (le_mul_of_one_le_left (sq_nonneg b) (show 1 ≤ 3/ε by apply (le_div_iff₀ hε).mpr; linarith)).trans_eq
    ring
  have hap : 0 < a := lt_of_le_of_ne ha (Ne.symm ha0)
  have hbp : 0 < b := lt_of_lt_of_le hap hab
  rw [abs_of_nonpos (sub_nonpos.mpr (Real.log_le_log hap hab))]
  have hl := log_difference_bound hap hab
  have hm := mul_le_mul_of_nonneg_left hl (show 0 ≤ 2*b by positivity)
  have hsq : (a-b)^2 ≤ (b-a)*(a+b) := by nlinarith
  apply (mul_le_mul_iff_of_pos_right hε).mp
  field_simp
  nlinarith [mul_le_mul_of_nonneg_left hε1 (sq_nonneg (a-b)), mul_nonneg ha (sub_nonneg.mpr hab)]

lemma integral_binEnvelope_le {a b ε : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b)
    (hε : 0 < ε) (hε1 : ε ≤ 1) :
    (∫ s in (0:ℝ)..1, binEnvelope a b ε s) ≤ 3/ε * |a-b| * (a+b) := by
  calc
    _ ≤ (a-b)^2 + 2*a*b*(|Real.log a-Real.log b|/ε) := by
      unfold binEnvelope
      rw [intervalIntegral.integral_add intervalIntegrable_const
        ((separated_integrable _ _ _ _).const_mul _), intervalIntegral.integral_const,
        intervalIntegral.integral_const_mul]
      simp only [sub_zero, one_smul]
      apply add_le_add_right
      have hi := integral_separated_le (u := Real.log a/ε) (v := Real.log b/ε)
      rw [← sub_div, abs_div, abs_of_pos hε] at hi
      exact mul_le_mul_of_nonneg_left hi (by positivity)
    _ ≤ _ := logarithmic_envelope_bound ha hb hε hε1

def binWeight (a ε s : ℝ) : ℝ :=
  if 0 < a then Real.exp (ε*((⌊Real.log a/ε+s⌋ : ℝ)-s)) else 0

lemma binWeight_nonneg (a ε s : ℝ) : 0 ≤ binWeight a ε s := by
  unfold binWeight; split <;> positivity

lemma binWeight_le {a ε : ℝ} (ha : 0 ≤ a) (hε : 0 < ε) (s : ℝ) :
    binWeight a ε s ≤ a := by
  unfold binWeight
  split_ifs with hap
  · apply le_trans (b := Real.exp (Real.log a))
    · apply Real.exp_le_exp.mpr
      have hf := Int.floor_le (Real.log a/ε+s)
      have hm := mul_le_mul_of_nonneg_left hf hε.le
      have he : ε*(Real.log a/ε+s) = Real.log a + ε*s := by field_simp
      linarith
    · exact (Real.exp_log hap).le
  · exact ha

lemma sub_binWeight_le {a ε : ℝ} (ha : 0 ≤ a) (hε : 0 < ε) (s : ℝ) :
    a - binWeight a ε s ≤ ε*a := by
  unfold binWeight
  split_ifs with hap
  · have hf := Int.lt_floor_add_one (Real.log a/ε+s)
    have hm := mul_lt_mul_of_pos_left hf hε
    have he : ε*(Real.log a/ε+s) = Real.log a + ε*s := by field_simp
    have hex : Real.exp (Real.log a - ε) ≤ Real.exp (ε*((⌊Real.log a/ε+s⌋ : ℝ)-s)) :=
      Real.exp_le_exp.mpr (by linarith)
    rw [Real.exp_sub, Real.exp_log hap] at hex
    have hex' : (1-ε)*a ≤ a / Real.exp ε := by
      have hh := Real.add_one_le_exp (-ε)
      rw [Real.exp_neg] at hh
      have hmul := mul_le_mul_of_nonneg_right hh ha
      simpa only [neg_add_eq_sub, div_eq_mul_inv, mul_comm] using hmul
    linarith
  · have : a = 0 := le_antisymm (le_of_not_gt hap) ha
    simp [this]

end ThresholdParallelRepetition.QuantumSampling

noncomputable section
open scoped BigOperators MatrixOrder ComplexOrder
open Matrix MeasureTheory
namespace ThresholdParallelRepetition.QuantumSampling
variable {n : Type u_n} [Fintype n] [DecidableEq n]

lemma unitary_row_normSq {U : Matrix n n ℂ} (hU : U * Uᴴ = 1) (i : n) :
    ∑ j, Complex.normSq (U i j) = 1 := by
  have h := congrArg Complex.re (congrFun (congrFun hU i) i)
  simpa only [Matrix.mul_apply, Matrix.conjTranspose_apply, Matrix.one_apply_eq,
    Complex.re_sum, Complex.one_re, Complex.star_def, Complex.mul_conj, Complex.ofReal_re] using h

lemma unitary_col_normSq {U : Matrix n n ℂ} (hU : Uᴴ * U = 1) (j : n) :
    ∑ i, Complex.normSq (U i j) = 1 := by
  simpa only [Matrix.conjTranspose_apply, Complex.star_def, Complex.normSq_conj] using
    unitary_row_normSq (U := Uᴴ) (by simpa only [Matrix.conjTranspose_conjTranspose] using hU) j

lemma hsSq_cfc_eq {A : Matrix n n ℂ} (hA : A.IsHermitian) (f : ℝ → ℝ) :
    hsSq (cfc f A) = ∑ i, (f (hA.eigenvalues i))^2 := by
  let U : Matrix n n ℂ := hA.eigenvectorUnitary
  have hU : Uᴴ * U = 1 := Unitary.star_mul_self_of_mem hA.eigenvectorUnitary.property
  have he : cfc f A = U * Matrix.diagonal (fun i => (f (hA.eigenvalues i) : ℂ)) * Uᴴ := by
    erw [hA.cfc_eq]; rfl
  rw [he, hsSq_mul_right (U := Uᴴ) (by simpa only [Matrix.conjTranspose_conjTranspose] using hU), hsSq_mul_left hU]
  unfold hsSq
  apply Finset.sum_congr rfl
  intro i _
  rw [Finset.sum_eq_single i]
  · simp [Complex.normSq_ofReal, pow_two]
  · intro j _ hji
    rw [Matrix.diagonal_apply_ne _ (Ne.symm hji), Complex.normSq_zero]
  · simp

lemma hsSq_eq_sum_eigenvalues_sq {A : Matrix n n ℂ} (hA : A.IsHermitian) :
    hsSq A = ∑ i, (hA.eigenvalues i)^2 := by
  have h := hsSq_cfc_eq hA (fun t => t)
  erw [cfc_id' ℝ A hA] at h
  exact h

def overlap {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) (i j : n) : ℝ :=
  Complex.normSq (((hA.eigenvectorUnitary : Matrix n n ℂ)ᴴ *
    (hB.eigenvectorUnitary : Matrix n n ℂ)) i j)

lemma overlap_nonneg {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) (i j : n) :
    0 ≤ overlap hA hB i j := Complex.normSq_nonneg _

lemma overlap_row {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) (i : n) :
    ∑ j, overlap hA hB i j = 1 := by
  apply unitary_row_normSq
  have h1 : (hA.eigenvectorUnitary : Matrix n n ℂ)ᴴ * hA.eigenvectorUnitary = 1 :=
    Unitary.star_mul_self_of_mem hA.eigenvectorUnitary.property
  have h2 : (hB.eigenvectorUnitary : Matrix n n ℂ) * (hB.eigenvectorUnitary : Matrix n n ℂ)ᴴ = 1 :=
    Unitary.mul_star_self_of_mem hB.eigenvectorUnitary.property
  simp only [Matrix.conjTranspose_mul, Matrix.conjTranspose_conjTranspose, Matrix.mul_assoc]
  rw [← Matrix.mul_assoc (hB.eigenvectorUnitary : Matrix n n ℂ), h2, Matrix.one_mul, h1]

lemma overlap_col {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) (j : n) :
    ∑ i, overlap hA hB i j = 1 := by
  apply unitary_col_normSq
  have h1 : (hA.eigenvectorUnitary : Matrix n n ℂ) * (hA.eigenvectorUnitary : Matrix n n ℂ)ᴴ = 1 :=
    Unitary.mul_star_self_of_mem hA.eigenvectorUnitary.property
  have h2 : (hB.eigenvectorUnitary : Matrix n n ℂ)ᴴ * hB.eigenvectorUnitary = 1 :=
    Unitary.star_mul_self_of_mem hB.eigenvectorUnitary.property
  simp only [Matrix.conjTranspose_mul, Matrix.conjTranspose_conjTranspose, Matrix.mul_assoc]
  rw [← Matrix.mul_assoc (hA.eigenvectorUnitary : Matrix n n ℂ), h1, Matrix.one_mul, h2]

lemma overlap_distance {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) :
    (∑ i, ∑ j, (hA.eigenvalues i - hB.eigenvalues j)^2 * overlap hA hB i j) = hsSq (A-B) := by
  have h := hsSq_spectral_mixed hA hB (fun t => t) (fun t => t)
  erw [cfc_id' ℝ A hA, cfc_id' ℝ B hB] at h
  exact h.symm

lemma overlap_square_sum_le {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) :
    (∑ i, ∑ j, (hA.eigenvalues i + hB.eigenvalues j)^2 * overlap hA hB i j) ≤
    2 * (hsSq A + hsSq B) := by
  calc
    _ ≤ ∑ i, ∑ j, (2*(hA.eigenvalues i)^2 + 2*(hB.eigenvalues j)^2) * overlap hA hB i j := by
      apply Finset.sum_le_sum; intro i _
      apply Finset.sum_le_sum; intro j _
      exact mul_le_mul_of_nonneg_right (by nlinarith [sq_nonneg (hA.eigenvalues i-hB.eigenvalues j)]) (overlap_nonneg _ _ _ _)
    _ = _ := by
      simp_rw [add_mul, Finset.sum_add_distrib]
      rw [Finset.sum_comm (f := fun i j => 2*(hB.eigenvalues j)^2 * overlap hA hB i j)]
      simp_rw [← Finset.mul_sum, overlap_row, overlap_col, mul_one]
      rw [← Finset.mul_sum, ← Finset.mul_sum, ← hsSq_eq_sum_eigenvalues_sq hA,
        ← hsSq_eq_sum_eigenvalues_sq hB]
      ring

lemma overlap_transport_le {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian) :
    (∑ i, ∑ j, |hA.eigenvalues i - hB.eigenvalues j| *
      (hA.eigenvalues i + hB.eigenvalues j) * overlap hA hB i j) ≤
      Real.sqrt (hsSq (A-B)) * Real.sqrt (2 * (hsSq A + hsSq B)) := by
  let r : n × n → ℝ := fun ij => |hA.eigenvalues ij.1 - hB.eigenvalues ij.2| *
    (hA.eigenvalues ij.1 + hB.eigenvalues ij.2) * overlap hA hB ij.1 ij.2
  let f : n × n → ℝ := fun ij => (hA.eigenvalues ij.1 - hB.eigenvalues ij.2)^2 * overlap hA hB ij.1 ij.2
  let g : n × n → ℝ := fun ij => (hA.eigenvalues ij.1 + hB.eigenvalues ij.2)^2 * overlap hA hB ij.1 ij.2
  have hc := Finset.sum_sq_le_sum_mul_sum_of_sq_le_mul (Finset.univ : Finset (n × n))
    (r := r) (f := f) (g := g)
    (fun ij _ => mul_nonneg (sq_nonneg _) (overlap_nonneg _ _ _ _))
    (fun ij _ => mul_nonneg (sq_nonneg _) (overlap_nonneg _ _ _ _))
    (fun ij _ => by dsimp [r,f,g]; rw [mul_pow, mul_pow, sq_abs]; exact le_of_eq (by ring))
  have hf : ∑ ij, f ij = hsSq (A-B) := by rw [Fintype.sum_prod_type]; exact overlap_distance hA hB
  have hg : ∑ ij, g ij ≤ 2 * (hsSq A + hsSq B) := by rw [Fintype.sum_prod_type]; exact overlap_square_sum_le hA hB
  rw [hf] at hc
  have hbound := hc.trans (mul_le_mul_of_nonneg_left hg (hsSq_nonneg _))
  have hr : ∑ ij, r ij = ∑ i, ∑ j, |hA.eigenvalues i - hB.eigenvalues j| *
      (hA.eigenvalues i + hB.eigenvalues j) * overlap hA hB i j := by rw [Fintype.sum_prod_type]
  rw [hr] at hbound
  have hprod : (Real.sqrt (hsSq (A-B)) * Real.sqrt (2*(hsSq A+hsSq B)))^2 =
      hsSq (A-B)*(2*(hsSq A+hsSq B)) := by
    rw [mul_pow, Real.sq_sqrt (hsSq_nonneg _), Real.sq_sqrt (by linarith [hsSq_nonneg A, hsSq_nonneg B])]
  have hnon : 0 ≤ Real.sqrt (hsSq (A-B)) * Real.sqrt (2*(hsSq A+hsSq B)) := by positivity
  rw [← hprod] at hbound
  exact le_of_sq_le_sq hbound hnon

end ThresholdParallelRepetition.QuantumSampling

noncomputable section
open scoped BigOperators MatrixOrder ComplexOrder Interval
open Matrix MeasureTheory
namespace ThresholdParallelRepetition.QuantumSampling
variable {n : Type u_n} [Fintype n] [DecidableEq n]

def spectralEnvelope {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian)
    (ε s : ℝ) : ℝ := ∑ i, ∑ j, binEnvelope (hA.eigenvalues i) (hB.eigenvalues j) ε s * overlap hA hB i j

lemma spectralEnvelope_integrable {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian)
    (ε : ℝ) : IntervalIntegrable (spectralEnvelope hA hB ε) volume 0 1 := by
  unfold spectralEnvelope
  simpa only [Finset.sum_fn] using IntervalIntegrable.sum Finset.univ
    (fun i _ => IntervalIntegrable.sum Finset.univ
      (fun j _ => (binEnvelope_integrable (hA.eigenvalues i) (hB.eigenvalues j) ε 0 1).mul_const (overlap hA hB i j)))

lemma integral_spectralEnvelope_le {A B : Matrix n n ℂ} (hA : A.PosSemidef) (hB : B.PosSemidef)
    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
    (∫ s in (0:ℝ)..1, spectralEnvelope hA.isHermitian hB.isHermitian ε s) ≤
    3/ε * (Real.sqrt (hsSq (A-B)) * Real.sqrt (2*(hsSq A+hsSq B))) := by
  unfold spectralEnvelope
  rw [intervalIntegral.integral_finsetSum (fun i _ =>
    (by simpa only [Finset.sum_fn] using IntervalIntegrable.sum Finset.univ (fun j _ => (binEnvelope_integrable (hA.isHermitian.eigenvalues i) (hB.isHermitian.eigenvalues j) ε 0 1).mul_const (overlap hA.isHermitian hB.isHermitian i j))))]
  simp_rw [intervalIntegral.integral_finsetSum (fun j _ => (binEnvelope_integrable _ _ _ _ _).mul_const _),
    intervalIntegral.integral_mul_const]
  calc
    _ ≤ ∑ i, ∑ j, (3/ε * |hA.isHermitian.eigenvalues i-hB.isHermitian.eigenvalues j| *
        (hA.isHermitian.eigenvalues i+hB.isHermitian.eigenvalues j)) * overlap hA.isHermitian hB.isHermitian i j := by
      apply Finset.sum_le_sum; intro i _
      apply Finset.sum_le_sum; intro j _
      exact mul_le_mul_of_nonneg_right
        (integral_binEnvelope_le (hA.eigenvalues_nonneg i) (hB.eigenvalues_nonneg j) hε hε1)
        (overlap_nonneg _ _ _ _)
    _ = (3/ε) * (∑ i, ∑ j, |hA.isHermitian.eigenvalues i-hB.isHermitian.eigenvalues j| *
        (hA.isHermitian.eigenvalues i+hB.isHermitian.eigenvalues j) * overlap hA.isHermitian hB.isHermitian i j) := by
      simp only [Finset.mul_sum, mul_assoc]
    _ ≤ _ := mul_le_mul_of_nonneg_left (overlap_transport_le hA.isHermitian hB.isHermitian) (by positivity)

lemma hsSq_sqrt_gram (M : Matrix n n ℂ) : hsSq (CFC.sqrt (Mᴴ * M)) = hsSq M := by
  have h := (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg (Mᴴ*M))).isHermitian.eq
  rw [hsSq_eq_trace, h, CFC.sqrt_mul_sqrt_self _ (Matrix.posSemidef_conjTranspose_mul_self M).nonneg,
    ← hsSq_eq_trace]

lemma integral_spectralEnvelope_unit_le {A B : Matrix n n ℂ} (hA : A.PosSemidef) (hB : B.PosSemidef)
    (hAe : hsSq A = 1) (hBe : hsSq B = 1) {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
    (∫ s in (0:ℝ)..1, spectralEnvelope hA.isHermitian hB.isHermitian ε s) ≤
    (6/ε) * Real.sqrt (hsSq (A-B)) := by
  have h := integral_spectralEnvelope_le hA hB hε hε1
  rw [hAe, hBe] at h
  norm_num at h
  convert h using 1; ring

lemma weighted_sqrt_le {ι : Type u_ι} [Fintype ι] (w e : ι → ℝ)
    (hw : ∀ i, 0 ≤ w i) (hE : ∀ i, 0 ≤ e i) (hs : ∑ i, w i = 1) :
    (∑ i, w i * Real.sqrt (e i)) ≤ Real.sqrt (∑ i, w i * e i) := by
  have hc := Finset.sum_sq_le_sum_mul_sum_of_sq_le_mul (Finset.univ : Finset ι)
    (r := fun i => w i * Real.sqrt (e i)) (f := fun i => w i) (g := fun i => w i * e i)
    (fun i _ => hw i) (fun i _ => mul_nonneg (hw i) (hE i))
    (fun i _ => by rw [mul_pow, Real.sq_sqrt (hE i)]; exact le_of_eq (by ring))
  rw [hs, one_mul, ← Real.sq_sqrt (Finset.sum_nonneg (fun i _ => mul_nonneg (hw i) (hE i)))] at hc
  exact le_of_sq_le_sq hc (Real.sqrt_nonneg _)

lemma exists_shift_spectralEnvelope_le {ι : Type u_ι} [Fintype ι] (w : ι → ℝ)
    (hw : ∀ i, 0 ≤ w i) (hs : ∑ i, w i = 1) (A B : ι → Matrix n n ℂ)
    (hA : ∀ i, (A i).PosSemidef) (hB : ∀ i, (B i).PosSemidef)
    (hAe : ∀ i, hsSq (A i) = 1) (hBe : ∀ i, hsSq (B i) = 1)
    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
    ∃ s : ℝ, (∑ i, w i * spectralEnvelope (hA i).isHermitian (hB i).isHermitian ε s) ≤
      (6/ε) * Real.sqrt (∑ i, w i * hsSq (A i-B i)) := by
  let F : ℝ → ℝ := fun s => ∑ i, w i * spectralEnvelope (hA i).isHermitian (hB i).isHermitian ε s
  have hF : IntervalIntegrable F volume 0 1 := by
    simpa only [F, Finset.sum_fn] using IntervalIntegrable.sum Finset.univ (fun i _ => (spectralEnvelope_integrable (hA i).isHermitian (hB i).isHermitian ε).const_mul (w i))
  let : IsProbabilityMeasure (volume.restrict (Set.Ioc (0:ℝ) 1)) := ⟨by simp⟩
  obtain ⟨s, hsF⟩ := MeasureTheory.exists_le_integral hF.1
  refine ⟨s, hsF.trans ?_⟩
  rw [← intervalIntegral.integral_of_le (show (0:ℝ) ≤ 1 by norm_num)]
  unfold F
  rw [intervalIntegral.integral_finsetSum (fun i _ => (spectralEnvelope_integrable _ _ _).const_mul _)]
  simp_rw [intervalIntegral.integral_const_mul]
  calc
    _ ≤ ∑ i, w i * ((6/ε) * Real.sqrt (hsSq (A i-B i))) := by
      apply Finset.sum_le_sum; intro i _
      exact mul_le_mul_of_nonneg_left (integral_spectralEnvelope_unit_le (hA i) (hB i) (hAe i) (hBe i) hε hε1) (hw i)
    _ = (6/ε) * ∑ i, w i * Real.sqrt (hsSq (A i-B i)) := by simp_rw [Finset.mul_sum]; apply Finset.sum_congr rfl; intro i _; ring
    _ ≤ _ := mul_le_mul_of_nonneg_left (weighted_sqrt_le w _ hw (fun i => hsSq_nonneg _) hs) (by positivity)

end ThresholdParallelRepetition.QuantumSampling

noncomputable section
open scoped BigOperators MatrixOrder ComplexOrder
open Matrix
namespace ThresholdParallelRepetition.QuantumSampling

def binScale (ε s : ℝ) (l : ℤ) : ℝ := Real.exp (ε*((l:ℝ)-s))
def binIndicator (ε s : ℝ) (l : ℤ) (a : ℝ) : ℝ :=
  if 0 < a ∧ ⌊Real.log a/ε+s⌋ = l then 1 else 0

lemma binIndicator_nonneg (ε s : ℝ) (l : ℤ) (a : ℝ) : 0 ≤ binIndicator ε s l a := by
  unfold binIndicator; split <;> norm_num
lemma binIndicator_sq (ε s : ℝ) (l : ℤ) (a : ℝ) : (binIndicator ε s l a)^2 = binIndicator ε s l a := by
  unfold binIndicator; split <;> norm_num
lemma binIndicator_mul_ne (ε s : ℝ) {l k : ℤ} (hlk : l ≠ k) (a : ℝ) :
    binIndicator ε s l a * binIndicator ε s k a = 0 := by
  unfold binIndicator
  split_ifs <;> simp_all

lemma sum_binIndicator_weight_sq_le (L : Finset ℤ) (ε s a : ℝ) :
    (∑ l ∈ L, (binScale ε s l)^2 * (binIndicator ε s l a)^2) ≤ (binWeight a ε s)^2 := by
  simp only [binIndicator_sq]
  by_cases ha : 0 < a
  · simp only [binIndicator, ha, true_and, mul_ite, mul_one, mul_zero, binWeight, ite_true]
    rw [Finset.sum_ite_eq]
    split_ifs with h
    · rfl
    · positivity
  · simp [binIndicator, ha, binWeight]

lemma scalar_mismatch_le (L : Finset ℤ) (ε s : ℝ) {a b : ℝ}
    (ha : 0 ≤ a) (hb : 0 ≤ b) (hε : 0 < ε) :
    (∑ l ∈ L, (binScale ε s l)^2 * (binIndicator ε s l a-binIndicator ε s l b)^2) ≤
      binEnvelope a b ε s := by
  have hh : (∑ l ∈ L, (binScale ε s l)^2 * (binIndicator ε s l a-binIndicator ε s l b)^2) ≤ a^2+b^2 := by
    calc
      _ ≤ ∑ l ∈ L, (binScale ε s l)^2 * ((binIndicator ε s l a)^2+(binIndicator ε s l b)^2) := by
        apply Finset.sum_le_sum; intro l _
        apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
        nlinarith [mul_nonneg (binIndicator_nonneg ε s l a) (binIndicator_nonneg ε s l b)]
      _ = (∑ l ∈ L, (binScale ε s l)^2 * (binIndicator ε s l a)^2) +
        (∑ l ∈ L, (binScale ε s l)^2 * (binIndicator ε s l b)^2) := by simp [mul_add, Finset.sum_add_distrib]
      _ ≤ (binWeight a ε s)^2 + (binWeight b ε s)^2 := add_le_add
          (sum_binIndicator_weight_sq_le L ε s a) (sum_binIndicator_weight_sq_le L ε s b)
      _ ≤ a^2+b^2 := by
        have ha' := binWeight_le ha hε s
        have hb' := binWeight_le hb hε s
        nlinarith [binWeight_nonneg a ε s, binWeight_nonneg b ε s]
  by_cases ha0 : a = 0
  · simpa [binEnvelope, ha0] using hh
  by_cases hb0 : b = 0
  · simpa [binEnvelope, hb0] using hh
  have hap : 0 < a := lt_of_le_of_ne ha (Ne.symm ha0)
  have hbp : 0 < b := lt_of_le_of_ne hb (Ne.symm hb0)
  by_cases he : ⌊Real.log a/ε+s⌋ = ⌊Real.log b/ε+s⌋
  · have hi : ∀ l, binIndicator ε s l a = binIndicator ε s l b := by intro l; simp [binIndicator, hap, hbp, he]
    simp only [hi, sub_self, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, mul_zero, Finset.sum_const_zero]
    exact binEnvelope_nonneg ha hb ε s
  · have hen : binEnvelope a b ε s = a^2+b^2 := by simp only [binEnvelope, separated, ite_eq_right he]; ring
    rw [hen]; exact hh

variable {n : Type u_n} [Fintype n] [DecidableEq n]

def binProjection (A : Matrix n n ℂ) (ε s : ℝ) (l : ℤ) : Matrix n n ℂ :=
  cfc (binIndicator ε s l) A

lemma binProjection_hermitian (A : Matrix n n ℂ) (ε s : ℝ) (l : ℤ) :
    (binProjection A ε s l).IsHermitian := (cfc_predicate (binIndicator ε s l) A).isHermitian

lemma binProjection_pos (A : Matrix n n ℂ) (ε s : ℝ) (l : ℤ) :
    (binProjection A ε s l).PosSemidef :=
  Matrix.nonneg_iff_posSemidef.mp (cfc_nonneg (fun a _ => binIndicator_nonneg ε s l a))

lemma binProjection_sq {A : Matrix n n ℂ} (_hA : A.IsHermitian) (ε s : ℝ) (l : ℤ) :
    binProjection A ε s l * binProjection A ε s l = binProjection A ε s l := by
  unfold binProjection
  erw [← cfc_mul (binIndicator ε s l) (binIndicator ε s l) A
    (A.finite_real_spectrum.continuousOn _) (A.finite_real_spectrum.continuousOn _)]
  apply cfc_congr
  intro a _
  simpa only [pow_two] using binIndicator_sq ε s l a

lemma binProjection_orthogonal {A : Matrix n n ℂ} (_hA : A.IsHermitian) (ε s : ℝ)
    {l k : ℤ} (hlk : l ≠ k) : binProjection A ε s l * binProjection A ε s k = 0 := by
  unfold binProjection
  erw [← cfc_mul (binIndicator ε s l) (binIndicator ε s k) A
    (A.finite_real_spectrum.continuousOn _) (A.finite_real_spectrum.continuousOn _)]
  calc
    _ = cfc (fun _ : ℝ => 0) A := by apply cfc_congr; intro a _; exact binIndicator_mul_ne ε s hlk a
    _ = 0 := cfc_zero ℝ A

lemma binProjection_mismatch_le (L : Finset ℤ) {A B : Matrix n n ℂ}
    (hA : A.PosSemidef) (hB : B.PosSemidef) {ε : ℝ} (hε : 0 < ε) (s : ℝ) :
    (∑ l ∈ L, (binScale ε s l)^2 * hsSq (binProjection A ε s l-binProjection B ε s l)) ≤
    spectralEnvelope hA.isHermitian hB.isHermitian ε s := by
  unfold binProjection spectralEnvelope
  simp_rw [hsSq_spectral_mixed hA.isHermitian hB.isHermitian, Finset.mul_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum; intro i _
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum; intro j _
  simp_rw [← mul_assoc, ← Finset.sum_mul]
  exact mul_le_mul_of_nonneg_right
    (scalar_mismatch_le L ε s (hA.eigenvalues_nonneg i) (hB.eigenvalues_nonneg j) hε)
    (overlap_nonneg _ _ _ _)

end ThresholdParallelRepetition.QuantumSampling

end
end
end
end

end OAI