Add lean source and binary files (part 84)

lean/OAI/InformationTheory/Entanglement/MatrixMeasure.lean

@@ -0,0 +1,72 @@
+import OAI.InformationTheory.Entanglement.DensityGap
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder ENNReal MeasureTheory Matrix.Norms.L2Operator
+open Matrix MeasureTheory
+namespace SecretKey
+open ChannelCompletion
+variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
+
+lemma complex_setIntegral_rnDeriv (c : ComplexMeasure Ω) [SigmaFinite μ]
+    (hc : c ≪ᵥ μ.toENNRealVectorMeasure) {s : Set Ω} (hs : MeasurableSet s) :
+    (∫ x in s, c.rnDeriv μ x ∂μ)=c s := by
+  have h := (ComplexMeasure.absolutelyContinuous_ennreal_iff c _).mp hc
+  have hr := congrArg (fun v : SignedMeasure Ω => v s)
+    (SignedMeasure.withDensityᵥ_rnDeriv_eq c.re μ h.1)
+  have hi := congrArg (fun v : SignedMeasure Ω => v s)
+    (SignedMeasure.withDensityᵥ_rnDeriv_eq c.im μ h.2)
+  rw [withDensityᵥ_apply (SignedMeasure.integrable_rnDeriv _ _) hs] at hr hi
+  apply Complex.ext
+  · exact (integral_re (c.integrable_rnDeriv μ).integrableOn).symm.trans hr
+  · exact (integral_im (c.integrable_rnDeriv μ).integrableOn).symm.trans hi
+
+lemma measurable_complex_rnDeriv (c : ComplexMeasure Ω) : Measurable (c.rnDeriv μ) := by
+  have he : c.rnDeriv μ = fun x => ((c.re.rnDeriv μ x : ℝ) : ℂ) +
+      ((c.im.rnDeriv μ x : ℝ) : ℂ)*Complex.I := by funext x; exact (Complex.re_add_im (c.rnDeriv μ x)).symm
+  rw [he]
+  exact (SignedMeasure.measurable_rnDeriv c.re μ).complex_ofReal.add
+    ((SignedMeasure.measurable_rnDeriv c.im μ).complex_ofReal.mul_const _)
+
+variable {n : Type} [Fintype n]
+
+structure PositiveMatrixMeasure (Ω : Type*) [MeasurableSpace Ω] (n : Type) [Fintype n] where
+  entry : Matrix n n (ComplexMeasure Ω)
+  positive : ∀ s, MeasurableSet s → Matrix.PosSemidef (fun i j => entry i j s)
+namespace PositiveMatrixMeasure
+variable (W : PositiveMatrixMeasure Ω n)
+def value (s : Set Ω) : Mat n := fun i j => W.entry i j s
+def density (μ : Measure Ω) (x : Ω) : Mat n := fun i j => (W.entry i j).rnDeriv μ x
+lemma density_integrable (i j : n) : Integrable (fun x => W.density μ x i j) μ :=
+  (W.entry i j).integrable_rnDeriv μ
+lemma density_measurable : Measurable (W.density μ) := by
+  change @Measurable Ω (n → n → ℂ) _ (borel _) _
+  rw [← @BorelSpace.measurable_eq (n → n → ℂ) _ MeasurableSpace.pi _]
+  exact Measurable.of_eval fun row => Measurable.of_eval fun column =>
+    measurable_complex_rnDeriv (W.entry row column)
+lemma entry_absolutelyContinuous
+    (hdom : ∀ s, MeasurableSet s → μ s=0 → (Matrix.trace (W.value s)).re=0) (i j : n) :
+    W.entry i j ≪ᵥ μ.toENNRealVectorMeasure := by
+  intro s hs
+  by_cases hsm : MeasurableSet s
+  · have hz : μ s=0 := by simpa only [Measure.toENNRealVectorMeasure_apply,ite_eq_left hsm] using hs
+    have hp := W.positive s hsm
+    have ht : Matrix.trace (W.value s)=0 := by
+      apply Complex.ext
+      · exact hdom s hsm hz
+      · exact (Complex.nonneg_iff.mp hp.trace_nonneg).2.symm
+    have hm : W.value s=0 := hp.trace_eq_zero_iff.mp ht
+    exact congrArg (fun M : Mat n => M i j) hm
+  · exact (W.entry i j).not_measurable hsm
+lemma density_setIntegral [SigmaFinite μ]
+    (hdom : ∀ s, MeasurableSet s → μ s=0 → (Matrix.trace (W.value s)).re=0)
+    {s : Set Ω} (hs : MeasurableSet s) (i j : n) :
+    (∫ x in s, W.density μ x i j ∂μ)=W.value s i j :=
+  complex_setIntegral_rnDeriv _ (W.entry_absolutelyContinuous hdom i j) hs
+end PositiveMatrixMeasure
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/MatrixMeasureChannel.lean

@@ -0,0 +1,160 @@
+import OAI.InformationTheory.Entanglement.FiniteRecovery
+import OAI.InformationTheory.Entanglement.FactorizedLawGap
+import OAI.InformationTheory.Entanglement.ChoiTransfer
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory Matrix Filter
+open scoped MeasureTheory BigOperators ComplexOrder MatrixOrder
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {T : Type*} [MeasurableSpace T] {n m : Type} [Fintype n] [Fintype m]
+  [DecidableEq n] [DecidableEq m]
+namespace PositiveMatrixMeasure
+omit [Fintype m] [DecidableEq m] in
+lemma channel_entry_value (W : PositiveMatrixMeasure T n) (F : Map n m) (s : Set T) :
+    (fun a b => (∑ i, ∑ j, F (Matrix.single i j 1) a b • W.entry i j) s)=F (W.value s) := by
+  rw [linearMap_entries F (W.value s)]
+  ext a b
+  simp only [_root_.sum_apply,_root_.smul_apply,smul_eq_mul,Matrix.sum_apply,Matrix.smul_apply,value]
+  apply Finset.sum_congr rfl
+  intro i _
+  apply Finset.sum_congr rfl
+  intro j _
+  exact mul_comm _ _
+
+def channel (W : PositiveMatrixMeasure T n) (F : Map n m) (hF : CP F) : PositiveMatrixMeasure T m where
+  entry a b := ∑ i, ∑ j, F (Matrix.single i j 1) a b • W.entry i j
+  positive s hs := by
+    rw [channel_entry_value]
+    exact cp_positive hF (W.positive s hs)
+omit [DecidableEq m] in
+lemma channel_value (W : PositiveMatrixMeasure T n) (F : Map n m) (hF : CP F) (s : Set T) :
+    (W.channel F hF).value s=F (W.value s) := channel_entry_value W F s
+omit [DecidableEq m] in
+lemma channel_traceMeasure (W : PositiveMatrixMeasure T n) (F : Map n m)
+    (hF : CP F) (hT : TracePreserving F) : (W.channel F hF).traceMeasure=W.traceMeasure := by
+  apply Measure.ext
+  intro s hs
+  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
+  change (W.channel F hF).traceMeasure.real s=W.traceMeasure.real s
+  rw [traceMeasure_real _ hs,traceMeasure_real _ hs,channel_value,hT]
+omit [Fintype m] [DecidableEq m] in
+lemma channel_entry (F : Map n m) (D : Mat n) (a b : m) :
+    F D a b=∑ i, ∑ j, D i j*F (Matrix.single i j 1) a b := by
+  rw [linearMap_entries F D]
+  simp only [Matrix.sum_apply,Matrix.smul_apply,smul_eq_mul]
+omit [Fintype m] [DecidableEq m] in
+lemma channel_density_integrable (F : Map n m) {μ : Measure T} (D : T → Mat n)
+    (hi : ∀ a b, Integrable (fun t => D t a b) μ) (a b : m) :
+    Integrable (fun t => F (D t) a b) μ := by
+  have he : (fun t => F (D t) a b)=(fun t => ∑ i, ∑ j, D t i j*F (Matrix.single i j 1) a b) :=
+    funext fun t => channel_entry F (D t) a b
+  rw [he]
+  exact integrable_finsetSum _ fun i _ => integrable_finsetSum _ fun j _ => (hi i j).mul_const _
+omit [Fintype m] [DecidableEq m] in
+lemma channel_setIntegral (F : Map n m) {μ : Measure T} (D : T → Mat n)
+    (hi : ∀ a b, Integrable (fun t => D t a b) μ) (s : Set T) (a b : m) :
+    (∫ t in s, F (D t) a b ∂μ)=F (fun i j => ∫ t in s, D t i j ∂μ) a b := by
+  have he : (fun t => F (D t) a b)=(fun t => ∑ i, ∑ j, D t i j*F (Matrix.single i j 1) a b) :=
+    funext fun t => channel_entry F (D t) a b
+  rw [he]
+  apply Eq.trans ?_ (channel_entry F (Matrix.of fun i j => ∫ t in s, D t i j ∂μ) a b).symm
+  rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ (fun j _ => (hi i j).integrableOn.mul_const _))]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [integral_finsetSum _ (fun j _ => (hi i j).integrableOn.mul_const _)]
+  simp only [integral_mul_const,Matrix.of_apply]
+omit [DecidableEq m] in
+lemma channel_positiveDensity (W : PositiveMatrixMeasure T n) (F : Map n m)
+    (hF : CP F) (hT : TracePreserving F) {μ : Measure T} [IsFiniteMeasure μ]
+    (hW : W.traceMeasure≪μ) :
+    (fun t => F (W.positiveDensity μ t))=ᵐ[μ](W.channel F hF).positiveDensity μ := by
+  apply (W.channel F hF).density_unique
+    (by simpa only [channel_traceMeasure W F hF hT] using hW)
+  · exact channel_density_integrable F _ (W.positiveDensity_integrable hW)
+  · intro s hs a b
+    rw [channel_setIntegral F _ (W.positiveDensity_integrable hW),channel_value]
+    have he : (Matrix.of fun i j => ∫ t in s, W.positiveDensity μ t i j ∂μ)=W.value s := by
+      ext i j
+      exact W.positiveDensity_setIntegral hW hs i j
+    exact congrArg (fun M : Mat n => F M a b) he
+end PositiveMatrixMeasure
+omit [DecidableEq m] in
+lemma bitComparisonMeasure_channel (W : Fin 2 → Fin 2 → PositiveMatrixMeasure T n)
+    (σ : PositiveMatrixMeasure T n) (F : Map n m) (hF : CP F) (hT : TracePreserving F) :
+    bitComparisonMeasure (fun i j => (W i j).channel F hF) (σ.channel F hF)=bitComparisonMeasure W σ := by
+  simp only [bitComparisonMeasure,familyTraceMeasure,PositiveMatrixMeasure.channel_traceMeasure _ F hF hT]
+omit [Fintype m] [DecidableEq n] [DecidableEq m] in
+lemma measurable_matrix_map (F : Map n m) : Measurable F := by
+  exact F.continuous_of_finiteDimensional.measurable
+omit [MeasurableSpace T] [Fintype n] [DecidableEq n] in
+lemma idealDensity_psd (σ : T → Mat n) (hσ : ∀ t, (σ t).PosSemidef) (i j : Fin 2) (t : T) :
+    (idealDensity σ i j t).PosSemidef := by
+  unfold idealDensity halfDensity
+  split_ifs
+  · exact (hσ t).smul (by rw [Complex.nonneg_iff]; norm_num)
+  · exact Matrix.PosSemidef.zero
+omit [Fintype n] [DecidableEq n] in
+lemma idealDensity_measurable (σ : T → Mat n) (hσ : Measurable σ) (i j : Fin 2) :
+    Measurable (idealDensity σ i j) := by
+  unfold idealDensity halfDensity
+  split_ifs
+  · exact hσ.const_smul (1/2 : ℂ)
+  · exact measurable_const
+omit [DecidableEq n] in
+lemma idealDensity_trace_integrable (σ : T → Mat n) {μ : Measure T}
+    (hσ : Integrable (fun t => (Matrix.trace (σ t)).re) μ) (i j : Fin 2) :
+    Integrable (fun t => (Matrix.trace (idealDensity σ i j t)).re) μ := by
+  unfold idealDensity
+  split_ifs
+  · simpa only [halfDensity_trace] using hσ.div_const 2
+  · simp only [Matrix.trace_zero,Complex.zero_re]; exact integrable_zero _ _ _
+omit [MeasurableSpace T] [Fintype n] [Fintype m] [DecidableEq n] [DecidableEq m] in
+lemma channel_idealDensity (F : Map n m) (σ : T → Mat n) (i j : Fin 2) (t : T) :
+    F (idealDensity σ i j t)=idealDensity (fun t => F (σ t)) i j t := by
+  unfold idealDensity halfDensity
+  split_ifs <;> simp only [map_smul,map_zero]
+
+theorem cqBitDistance_channel (W : Fin 2 → Fin 2 → PositiveMatrixMeasure T n)
+    (σ : PositiveMatrixMeasure T n) (F : Map n m) (hF : CP F) (hT : TracePreserving F) :
+    cqBitDistance (fun i j => (W i j).channel F hF) (σ.channel F hF) ≤ cqBitDistance W σ := by
+  have htr : ∀ A, Matrix.trace (F A)=Matrix.trace A := hT
+  let μ := bitComparisonMeasure W σ
+  have hW (i j : Fin 2) := (W i j).channel_positiveDensity F hF hT (bitComparison_actual_dom W σ i j)
+  have hσ := σ.channel_positiveDensity F hF hT (bitComparison_ideal_dom W σ)
+  unfold cqBitDistance
+  rw [bitComparisonMeasure_channel W σ F hF hT,
+    ← bitDistance_congr_ae hW hσ]
+  apply Finset.sum_le_sum
+  intro i _
+  apply Finset.sum_le_sum
+  intro j _
+  apply integral_mono
+  · apply integrable_traceNorm_sub
+    · exact (measurable_matrix_map F).comp ((W i j).positiveDensity_measurable μ)
+    · exact idealDensity_measurable _ ((measurable_matrix_map F).comp (σ.positiveDensity_measurable μ)) i j
+    · intro t; exact cp_positive hF ((W i j).positiveDensity_psd μ t)
+    · exact idealDensity_psd _ (fun t => cp_positive hF (σ.positiveDensity_psd μ t)) i j
+    · simpa only [htr] using (W i j).positiveDensity_trace_integrable (bitComparison_actual_dom W σ i j)
+    · apply idealDensity_trace_integrable
+      simpa only [htr] using σ.positiveDensity_trace_integrable (bitComparison_ideal_dom W σ)
+  · apply integrable_traceNorm_sub
+    · exact (W i j).positiveDensity_measurable μ
+    · exact idealDensity_measurable _ (σ.positiveDensity_measurable μ) i j
+    · exact (W i j).positiveDensity_psd μ
+    · exact idealDensity_psd _ (σ.positiveDensity_psd μ) i j
+    · exact (W i j).positiveDensity_trace_integrable (bitComparison_actual_dom W σ i j)
+    · exact idealDensity_trace_integrable _ (σ.positiveDensity_trace_integrable (bitComparison_ideal_dom W σ)) i j
+  · intro t
+    dsimp only
+    rw [← channel_idealDensity F (σ.positiveDensity μ) i j t,← map_sub]
+    exact traceNorm_cptp F hF hT (((W i j).positiveDensity_psd μ t).isHermitian.sub
+      (idealDensity_psd _ (σ.positiveDensity_psd μ) i j t).isHermitian)
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/MatrixPolar.lean

@@ -0,0 +1,72 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped MatrixOrder ComplexOrder BigOperators
+open Matrix
+namespace MatrixPolar
+
+lemma isometry_factor {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+    [FiniteDimensional ℂ V] (f g : V →ₗ[ℂ] V)
+    (hn : ∀ x, ‖f x‖ = ‖g x‖) :
+    ∃ U : V →ₗᵢ[ℂ] V, U.toLinearMap.comp g = f := by
+  have hk : g.ker ≤ f.ker := by
+    intro x hx
+    apply LinearMap.mem_ker.mpr
+    apply norm_eq_zero.mp
+    rw [hn, LinearMap.mem_ker.mp hx, norm_zero]
+  let l : g.range →ₗ[ℂ] V :=
+    (g.ker.liftQ f hk).comp g.quotKerEquivRange.symm.toLinearMap
+  have hl (x : V) : l ⟨g x, LinearMap.mem_range_self g x⟩ = f x := by
+    simp [l]
+  have hln (x : g.range) : ‖l x‖ = ‖x‖ := by
+    rcases x with ⟨x,hx⟩
+    obtain ⟨y,rfl⟩ := hx
+    rw [hl]
+    exact hn y
+  let L : g.range →ₗᵢ[ℂ] V := ⟨l,hln⟩
+  refine ⟨L.extend,?_⟩
+  ext x
+  change L.extend (g x) = f x
+  rw [show L.extend (g x) = L ⟨g x, LinearMap.mem_range_self g x⟩ from
+    L.extend_apply ⟨g x, LinearMap.mem_range_self g x⟩]
+  exact hl x
+
+variable {n : Type*} [Fintype n] [DecidableEq n]
+lemma gram_inner (A : Matrix n n ℂ) (x y : EuclideanSpace ℂ n) :
+    inner ℂ (Matrix.toEuclideanLin A x) (Matrix.toEuclideanLin A y) =
+      inner ℂ x (Matrix.toEuclideanLin (Aᴴ * A) y) := by
+  rw [Matrix.toLpLin_mul 2 2 2, Matrix.toEuclideanLin_conjTranspose_eq_adjoint]
+  exact (LinearMap.adjoint_inner_right (Matrix.toEuclideanLin A) x
+    (Matrix.toEuclideanLin A y)).symm
+
+lemma sqrt_gram_norm (A : Matrix n n ℂ) (x : EuclideanSpace ℂ n) :
+    ‖Matrix.toEuclideanLin A x‖ =
+      ‖Matrix.toEuclideanLin (CFC.sqrt (Aᴴ * A)) x‖ := by
+  have h : (CFC.sqrt (Aᴴ * A))ᴴ * CFC.sqrt (Aᴴ * A) = Aᴴ * A := by
+    rw [(Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg (Aᴴ * A))).isHermitian.eq]
+    exact CFC.sqrt_mul_sqrt_self _ (Matrix.posSemidef_conjTranspose_mul_self A).nonneg
+  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  rw [norm_sq_eq_re_inner (𝕜 := ℂ), norm_sq_eq_re_inner (𝕜 := ℂ), gram_inner, gram_inner, h]
+
+lemma polar (A : Matrix n n ℂ) :
+    ∃ U : Matrix n n ℂ, Uᴴ * U = 1 ∧ A = U * CFC.sqrt (Aᴴ * A) := by
+  obtain ⟨l,hl⟩ := isometry_factor (Matrix.toEuclideanLin A)
+    (Matrix.toEuclideanLin (CFC.sqrt (Aᴴ * A))) (sqrt_gram_norm A)
+  let U := Matrix.toEuclideanLin.symm l.toLinearMap
+  have hU : Matrix.toEuclideanLin U = l.toLinearMap := Matrix.toEuclideanLin.apply_symm_apply _
+  refine ⟨U,?_,?_⟩
+  · apply Matrix.toEuclideanLin.injective
+    rw [Matrix.toLpLin_mul 2 2 2, Matrix.toEuclideanLin_conjTranspose_eq_adjoint,
+      hU, Matrix.toLpLin_one]
+    exact l.adjoint_comp_self'
+  · apply Matrix.toEuclideanLin.injective
+    rw [Matrix.toLpLin_mul 2 2 2, hU]
+    exact hl.symm
+
+end MatrixPolar
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/MatrixTraceMeasure.lean

@@ -0,0 +1,86 @@
+import OAI.InformationTheory.Entanglement.DensityPositivity
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder ENNReal MeasureTheory Matrix.Norms.L2Operator
+open Matrix MeasureTheory Filter
+attribute [local instance] Classical.propDecidable
+namespace SecretKey
+open ChannelCompletion
+variable {Ω : Type*} [MeasurableSpace Ω] {n : Type} [Fintype n]
+namespace PositiveMatrixMeasure
+variable (W : PositiveMatrixMeasure Ω n)
+def traceSigned : SignedMeasure Ω := ComplexMeasure.re (∑ i, W.entry i i)
+lemma traceSigned_apply (s : Set Ω) : W.traceSigned s=(Matrix.trace (W.value s)).re := by
+  change ((∑ i, W.entry i i) s).re=_
+  simp only [_root_.sum_apply,value,Matrix.trace,Matrix.diag]
+lemma traceSigned_nonneg : 0 ≤[Set.univ] W.traceSigned := by
+  apply VectorMeasure.restrict_le_restrict_of_subset_le
+  intro s hs _
+  change 0≤W.traceSigned s
+  rw [W.traceSigned_apply]
+  exact
+    (Complex.nonneg_iff.mp (W.positive s hs).trace_nonneg).1
+
+def traceMeasure : Measure Ω :=
+  W.traceSigned.toMeasureOfZeroLE Set.univ MeasurableSet.univ W.traceSigned_nonneg
+instance : IsFiniteMeasure W.traceMeasure := SignedMeasure.toMeasureOfZeroLE_finite _ _ _
+lemma traceMeasure_real {s : Set Ω} (hs : MeasurableSet s) :
+    W.traceMeasure.real s=(Matrix.trace (W.value s)).re := by
+  rw [traceMeasure,SignedMeasure.toMeasureOfZeroLE_real_apply _ _ _ hs,Set.univ_inter,
+    W.traceSigned_apply]
+lemma trace_domination {μ : Measure Ω} (h : W.traceMeasure≪μ) :
+    ∀ s, MeasurableSet s → μ s=0 → (Matrix.trace (W.value s)).re=0 := by
+  intro s hs hz
+  rw [← W.traceMeasure_real hs,measureReal_def,h hz,ENNReal.toReal_zero]
+
+def positiveDensity (μ : Measure Ω) (x : Ω) : Mat n :=
+  if (W.density μ x).PosSemidef then W.density μ x else 0
+lemma positiveDensity_psd (μ : Measure Ω) (x : Ω) : (W.positiveDensity μ x).PosSemidef := by
+  unfold positiveDensity
+  split
+  · assumption
+  · exact Matrix.PosSemidef.zero
+lemma positiveDensity_measurable [DecidableEq n] (μ : Measure Ω) :
+    Measurable (W.positiveDensity μ) := by
+  apply (W.density_measurable (μ := μ)).ite _ measurable_const
+  simpa only [Matrix.nonneg_iff_posSemidef] using
+    measurableSet_le (show Measurable (fun _ : Ω => (0 : Mat n)) from measurable_const)
+      (W.density_measurable (μ := μ))
+lemma positiveDensity_ae_eq {μ : Measure Ω} [SigmaFinite μ] (h : W.traceMeasure≪μ) :
+    W.positiveDensity μ=ᵐ[μ] W.density μ := by
+  filter_upwards [W.density_ae_psd (W.trace_domination h)] with x hx
+  exact ite_eq_left hx
+lemma positiveDensity_integrable {μ : Measure Ω} [SigmaFinite μ] (h : W.traceMeasure≪μ)
+    (i j : n) : Integrable (fun x => W.positiveDensity μ x i j) μ := by
+  refine (W.density_integrable i j).congr ?_
+  filter_upwards [W.positiveDensity_ae_eq h] with x hx
+  exact (congrArg (fun M : Mat n => M i j) hx).symm
+lemma positiveDensity_setIntegral {μ : Measure Ω} [SigmaFinite μ] (h : W.traceMeasure≪μ)
+    {s : Set Ω} (hs : MeasurableSet s) (i j : n) :
+    (∫ x in s, W.positiveDensity μ x i j ∂μ)=W.value s i j := by
+  rw [integral_congr_ae (ae_restrict_of_ae (W.positiveDensity_ae_eq h |>.mono
+    (fun x hx => congrArg (fun M : Mat n => M i j) hx)))]
+  exact W.density_setIntegral (W.trace_domination h) hs i j
+lemma positiveDensity_trace_integrable {μ : Measure Ω} [SigmaFinite μ] (h : W.traceMeasure≪μ) :
+    Integrable (fun x => (Matrix.trace (W.positiveDensity μ x)).re) μ := by
+  exact (integrable_finsetSum _ fun i _ => W.positiveDensity_integrable h i i).re
+lemma positiveDensity_trace_setIntegral {μ : Measure Ω} [SigmaFinite μ] (h : W.traceMeasure≪μ)
+    {s : Set Ω} (hs : MeasurableSet s) :
+    (∫ x in s, (Matrix.trace (W.positiveDensity μ x)).re ∂μ)=W.traceMeasure.real s := by
+  rw [W.traceMeasure_real hs]
+  change (∫ x in s, RCLike.re (Matrix.trace (W.positiveDensity μ x)) ∂μ)=_
+  have hi : Integrable (fun x => Matrix.trace (W.positiveDensity μ x)) μ :=
+    integrable_finsetSum Finset.univ (fun i _ => W.positiveDensity_integrable h i i)
+  rw [integral_re hi.integrableOn]
+  exact congrArg Complex.re ((integral_finsetSum Finset.univ
+    (fun i _ => (W.positiveDensity_integrable h i i).integrableOn)).trans
+    (Finset.sum_congr rfl (fun i _ => W.positiveDensity_setIntegral h hs i i)))
+end PositiveMatrixMeasure
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/MultiTensor.lean

@@ -0,0 +1,84 @@
+import OAI.InformationTheory.Entanglement.ProjectionData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+open Matrix
+namespace FiniteConstruction
+open ChannelCompletion
+variable {S V A : Type} [Fintype S] [Fintype V] [Fintype A]
+  [DecidableEq S] [DecidableEq V]
+
+def multiTensor (M : S → Mat V) : Mat (S → V) := fun i j => ∏ s, M s (i s) (j s)
+omit [DecidableEq V] in
+lemma multiTensor_mul (M N : S → Mat V) :
+    multiTensor M*multiTensor N=multiTensor (fun s => M s*N s) := by
+  ext i j
+  simp only [Matrix.mul_apply,multiTensor,← Finset.prod_mul_distrib]
+  exact (Fintype.prod_sum (fun s : S => fun k : V => M s (i s) k*N s k (j s))).symm
+omit [Fintype V] [DecidableEq S] in
+lemma multiTensor_one : multiTensor (fun _ : S => (1 : Mat V))=1 := by
+  ext i j
+  simp only [multiTensor,Matrix.one_apply]
+  rw [Fintype.prod_boole]
+  simp only [funext_iff]
+omit [Fintype V] [DecidableEq S] [DecidableEq V] in
+lemma multiTensor_zero_of (M : S → Mat V) (s : S) (hs : M s=0) : multiTensor M=0 := by
+  ext i j
+  change (∏ t, M t (i t) (j t))=0
+  exact Finset.prod_eq_zero (Finset.mem_univ s) (by rw [hs]; rfl)
+omit [Fintype V] [DecidableEq S] [DecidableEq V] in
+lemma multiTensor_adjoint (M : S → Mat V) :
+    (multiTensor M)ᴴ=multiTensor (fun s => (M s)ᴴ) := by
+  ext i j
+  simp [multiTensor,Matrix.conjTranspose_apply]
+omit [Fintype V] [DecidableEq S] [DecidableEq V] in
+lemma multiTensor_hermitian (M : S → Mat V) (hM : ∀ s, (M s).IsHermitian) :
+    (multiTensor M).IsHermitian := by
+  rw [Matrix.IsHermitian,multiTensor_adjoint]
+  simp_rw [(hM _).eq]
+omit [DecidableEq V] in
+lemma multiTensor_idempotent (M : S → Mat V) (hM : ∀ s, M s*M s=M s) :
+    multiTensor M*multiTensor M=multiTensor M := by
+  rw [multiTensor_mul]
+  simp_rw [hM]
+omit [DecidableEq V] in
+lemma multiTensor_commute (M N : S → Mat V) (h : ∀ s, M s*N s=N s*M s) :
+    multiTensor M*multiTensor N=multiTensor N*multiTensor M := by
+  rw [multiTensor_mul,multiTensor_mul]
+  simp_rw [h]
+omit [DecidableEq V] in
+lemma multiTensor_trace (M : S → Mat V) :
+    Matrix.trace (multiTensor M)=∏ s, Matrix.trace (M s) := by
+  change (∑ i : S → V, ∏ s, M s (i s) (i s))=∏ s, ∑ i, M s i i
+  exact (Fintype.prod_sum (fun s : S => fun i : V => M s i i)).symm
+omit [Fintype V] [DecidableEq V] in
+lemma multiTensor_sum (M : S → A → Mat V) :
+    (∑ a : S → A, multiTensor (fun s => M s (a s)))=
+      multiTensor (fun s => ∑ a, M s a) := by
+  ext i j
+  simp only [Matrix.sum_apply,multiTensor]
+  exact (Fintype.prod_sum (fun s : S => fun a : A => M s a (i s) (j s))).symm
+omit [Fintype V] in
+lemma multiTensor_complete (M : S → A → Mat V) (hM : ∀ s, ∑ a, M s a=1) :
+    (∑ a : S → A, multiTensor (fun s => M s (a s)))=1 := by
+  rw [multiTensor_sum]
+  simp only [hM,multiTensor_one]
+omit [Fintype A] [DecidableEq V] in
+lemma multiTensor_orthogonal (M : S → A → Mat V)
+    (hM : ∀ s a b, a ≠ b → M s a*M s b=0)
+    (a b : S → A) (hab : a ≠ b) :
+    multiTensor (fun s => M s (a s))*multiTensor (fun s => M s (b s))=0 := by
+  rw [multiTensor_mul]
+  obtain ⟨s,hs⟩ := Function.ne_iff.mp hab
+  exact multiTensor_zero_of _ s (hM s _ _ hs)
+omit [DecidableEq V] in
+lemma multiTensor_trace_mul (M N : S → Mat V) :
+    Matrix.trace (multiTensor M*multiTensor N)=∏ s, Matrix.trace (M s*N s) := by
+  rw [multiTensor_mul,multiTensor_trace]
+end FiniteConstruction
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/NormalizeRepresentation.lean

@@ -0,0 +1,66 @@
+import OAI.InformationTheory.Entanglement.TensorTools
+import OAI.InformationTheory.Entanglement.EffectNormalization
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {n m p q : Type} [Fintype n] [Fintype m] [Fintype p] [Fintype q]
+  [DecidableEq n] [DecidableEq m] [DecidableEq p] [DecidableEq q]
+
+lemma ad_one : ad (1 : Mat n)=LinearMap.id := by
+  ext A i j
+  simp [ad_apply]
+
+omit [DecidableEq p] [DecidableEq q] in
+lemma tensorMap_ad_left (F : Map n p) (G : Map m q) (S : Mat n) :
+    tensorMap (F.comp (ad S)) G=(tensorMap F G).comp (ad (S ⊗ₖ (1 : Mat m))) := by
+  rw [← tensorMap_ad,ad_one,tensorMap_comp]
+  simp
+
+omit [Fintype p] [DecidableEq n] [DecidableEq p] in
+lemma cp_ad_input_transpose {F : Map n p} (hFT : CP (F.comp transposeMap)) (S : Mat n) :
+    CP ((F.comp (ad S)).comp transposeMap) := by
+  have he : (ad S).comp transposeMap = transposeMap.comp (ad (Sᴴ)ᵀ) := by
+    have hs : ((Sᴴ)ᵀ)ᴴ=Sᵀ := by
+      ext i j
+      simp [Matrix.conjTranspose_apply]
+    ext A i j
+    simp only [LinearMap.comp_apply,transposeMap_apply,ad_apply,hs,
+      Matrix.transpose_mul,Matrix.transpose_transpose,Matrix.mul_assoc]
+  rw [LinearMap.comp_assoc,he,← LinearMap.comp_assoc]
+  exact cp_comp hFT (cp_ad _)
+
+omit [DecidableEq q] in
+lemma normalized_representation (R : Mat (p × q)) (hR : Represented R)
+    (X : Fin 2 → Mat p) (hX : ∀ i, (X i).PosSemidef) :
+    ∃ r s : ℕ, 0<r ∧ 0<s ∧
+      ∃ (L : Map (Fin r) p) (M : Map (Fin s) q) (χ : Fin r × Fin s → ℂ),
+        CP L ∧ CP (L.comp transposeMap) ∧ CP M ∧ CP (M.comp transposeMap) ∧
+        R=tensorMap L M (projector χ) ∧ Commute (hsAdjoint L (X 0)) (hsAdjoint L (X 1)) := by
+  obtain ⟨_,_,r,s,hr,hs,L,M,χ,hL,hLT,hM,hMT,hR⟩ := hR
+  have hA (i : Fin 2) := cp_positive (cp_hsAdjoint hL) (hX i)
+  obtain ⟨S,T,hST,hTS,hcomm⟩ := commuting_normalization (hA 0) (hA 1)
+  refine ⟨r,s,hr,hs,L.comp (ad S),M,(T ⊗ₖ (1 : Mat (Fin s))).mulVec χ,
+    cp_comp hL (cp_ad S),cp_ad_input_transpose hLT S,hM,hMT,?_,?_⟩
+  · rw [tensorMap_ad_left,LinearMap.comp_apply,← ad_projector,hR]
+    congr 1
+    symm
+    rw [ad_apply,ad_apply]
+    have hprod : (S ⊗ₖ (1 : Mat (Fin s)))*(T ⊗ₖ (1 : Mat (Fin s)))=1 := by
+      rw [← Matrix.mul_kronecker_mul,hST,Matrix.one_mul,Matrix.one_kronecker_one]
+    calc
+      (S ⊗ₖ 1) * ((T ⊗ₖ 1) * projector χ * (T ⊗ₖ 1)ᴴ) * (S ⊗ₖ 1)ᴴ =
+        ((S ⊗ₖ 1)*(T ⊗ₖ 1))*projector χ*((S ⊗ₖ 1)*(T ⊗ₖ 1))ᴴ := by
+          simp only [Matrix.conjTranspose_mul,Matrix.mul_assoc]
+      _ = projector χ := by rw [hprod,Matrix.conjTranspose_one,Matrix.one_mul,Matrix.mul_one]
+  · rw [hsAdjoint_ad_comp hL,hsAdjoint_ad_comp hL]
+    exact hcomm
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/NormalizedProbe.lean

@@ -0,0 +1,91 @@
+import OAI.InformationTheory.Entanglement.FiniteInputInstrument
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder MeasureTheory Kronecker ENNReal NNReal
+open MeasureTheory Matrix
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {Ω : Type*} [MeasurableSpace Ω]
+variable {n e d : Type} [Fintype n] [Fintype e] [Fintype d]
+  [DecidableEq n] [DecidableEq e] [DecidableEq d]
+namespace PositiveMatrixMeasure
+
+omit [DecidableEq n] [DecidableEq e] [DecidableEq d] in
+theorem filter_comp (W : PositiveMatrixMeasure Ω n) (B : Matrix e n ℂ)
+    (C : Matrix d e ℂ) : (W.filter B).filter C=W.filter (C*B) := by
+  apply ext_entry_default
+  ext i j s hs
+  change ((W.filter B).filter C).value s i j=(W.filter (C*B)).value s i j
+  rw [filter_value,filter_value,filter_value,Matrix.conjTranspose_mul]
+  simp only [Matrix.mul_assoc]
+end PositiveMatrixMeasure
+namespace FiniteInputInstrument
+variable (I : FiniteInputInstrument n Ω)
+
+def normalizedProbe : PositiveMatrixMeasure Ω n :=
+  I.rawProbe.filter (((Real.sqrt (Fintype.card n : ℝ) : ℂ)⁻¹) • (1 : Mat n))
+omit [DecidableEq n] in
+lemma sqrt_card_ne_zero [Nonempty n] : (Real.sqrt (Fintype.card n : ℝ) : ℂ)≠0 := by
+  exact_mod_cast (Real.sqrt_pos.2 (by exact_mod_cast Fintype.card_pos)).ne'
+omit [DecidableEq n] in
+lemma sqrt_card_mul : (Real.sqrt (Fintype.card n : ℝ) : ℂ)*
+    (Real.sqrt (Fintype.card n : ℝ) : ℂ)=(Fintype.card n : ℂ) := by
+  rw [← Complex.ofReal_mul,Real.mul_self_sqrt (by positivity),Complex.ofReal_natCast]
+
+theorem normalizedProbe_value (s : Set Ω) :
+    I.normalizedProbe.value s=(Fintype.card n : ℂ)⁻¹ • I.rawProbe.value s := by
+  unfold normalizedProbe
+  rw [PositiveMatrixMeasure.filter_value,Matrix.conjTranspose_smul,
+    Matrix.conjTranspose_one]
+  simp only [map_inv₀,Complex.star_def,Complex.conj_ofReal,Matrix.smul_mul,
+    Matrix.one_mul,Matrix.mul_smul,Matrix.mul_one,smul_smul]
+  rw [← mul_inv,sqrt_card_mul]
+
+omit [DecidableEq e] in
+theorem normalizedProbe_filter [Nonempty n] (B : Matrix e n ℂ) :
+    I.normalizedProbe.filter ((Real.sqrt (Fintype.card n : ℝ) : ℂ) • B)=
+      I.purificationLaw B := by
+  rw [purificationLaw_eq_filter]
+  unfold normalizedProbe
+  rw [PositiveMatrixMeasure.filter_comp]
+  congr 1
+  rw [Matrix.smul_mul,Matrix.mul_smul,Matrix.mul_one,smul_smul,
+    mul_inv_cancel₀ sqrt_card_ne_zero,one_smul]
+theorem normalizedProbe_trace [Nonempty n] :
+    Matrix.trace (I.normalizedProbe.value Set.univ)=1 := by
+  rw [normalizedProbe_value,rawProbe_total,Matrix.trace_smul,Matrix.trace_one]
+  change (Fintype.card n : ℂ)⁻¹*(Fintype.card n : ℂ)=1
+  exact inv_mul_cancel₀ (by exact_mod_cast (Fintype.card_pos : 0<Fintype.card n).ne')
+instance normalizedProbe_probability [Nonempty n] :
+    IsProbabilityMeasure I.normalizedProbe.traceMeasure := by
+  constructor
+  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) ENNReal.one_ne_top).mp
+  change I.normalizedProbe.traceMeasure.real Set.univ=(1 : ℝ≥0∞).toReal
+  rw [PositiveMatrixMeasure.traceMeasure_real _ MeasurableSet.univ,I.normalizedProbe_trace]
+  simp
+end FiniteInputInstrument
+
+lemma product_normalized_probe_amplitude {a b : Type} [Fintype a] [Fintype b]
+    [DecidableEq a] [DecidableEq b] :
+    (((Real.sqrt (Fintype.card a : ℝ) : ℂ)⁻¹ • (1 : Mat a)) ⊗ₖ
+      ((Real.sqrt (Fintype.card b : ℝ) : ℂ)⁻¹ • (1 : Mat b)))=
+      (Real.sqrt (Fintype.card (a×b) : ℝ) : ℂ)⁻¹ • (1 : Mat (a×b)) := by
+  rw [Matrix.smul_kronecker,Matrix.kronecker_smul,smul_smul,Matrix.one_kronecker_one,
+    ← mul_inv,← Complex.ofReal_mul,← Real.sqrt_mul (by positivity)]
+  simp only [Fintype.card_prod,Nat.cast_mul]
+
+theorem normalized_product_probe_filter {a b : Type} [Fintype a] [Fintype b]
+    [DecidableEq a] [DecidableEq b] [Nonempty a] [Nonempty b]
+    (I : FiniteInputInstrument (a×b) Ω) (R : Mat (a×b)) :
+    I.normalizedProbe.filter (canonicalProbeFilter R)=
+      I.purificationLaw (CFC.sqrt R)ᵀ := by
+  convert I.normalizedProbe_filter (CFC.sqrt R)ᵀ using 1
+  simp only [canonicalProbeFilter,Fintype.card_prod,Nat.cast_mul]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/NormalizedPurificationConsumer.lean

@@ -0,0 +1,92 @@
+import OAI.InformationTheory.Entanglement.ArbitraryPurificationConsumer
+import OAI.InformationTheory.Entanglement.ProbeRescaling
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ENNReal NNReal MeasureTheory InnerProductSpace ComplexOrder MatrixOrder Kronecker
+open MeasureTheory Matrix ContinuousLinearMap ProbabilityTheory Filter
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {T : Type*} [MeasurableSpace T]
+variable {n m : Type} [Fintype n] [Fintype m] [DecidableEq n] [DecidableEq m]
+omit [DecidableEq n] in
+lemma hilbertEmbed_smul_vectors {H : Type*} [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H] (x : n→H) (d : ℂ) (A : Mat n) :
+    hilbertEmbed (fun i => d • x i) A=hilbertEmbed x ((d*star d) • A) := by
+  ext u
+  rw [hilbertEmbed_apply,hilbertEmbed_apply]
+  apply Finset.sum_congr rfl; intro i hi
+  apply Finset.sum_congr rfl; intro j hj
+  simp only [inner_smul_left,smul_smul,Matrix.smul_apply,smul_eq_mul]
+  congr 1
+  simp only [starRingEnd_apply]
+  ring
+omit [DecidableEq n] in
+lemma hilbertEmbed_normalized_filter {H : Type*} [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H] (x : n→H) (A : Mat n) :
+    hilbertEmbed (fun i => (Real.sqrt (Fintype.card n : ℝ) : ℂ) • x i) A=
+      hilbertEmbed x ((Fintype.card n : ℂ) • A) := by
+  rw [hilbertEmbed_smul_vectors,Complex.star_def,Complex.conj_ofReal,
+    FiniteInputInstrument.sqrt_card_mul]
+
+theorem normalized_purification_tested_gap
+    {Ω : Type*} {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω]
+    (ν : Measure Ω) [IsFiniteMeasure ν] (t : Ω→T) (ht : Measurable t)
+    {A B : MeasurableSpace Ω} (hA : A ≤ mΩ) (hB : B ≤ mΩ)
+    (hind : CondIndep (MeasurableSpace.comap t inferInstance) A B ht.comap_le ν)
+    (a : Fin 2→Option (PositiveTestIndex n)→Set Ω)
+    (q : Fin 2→Option (PositiveTestIndex m)→Set Ω)
+    (ha : ∀ i r, MeasurableSet[A] (a i r)) (hq : ∀ j s, MeasurableSet[B] (q j s))
+    (M : Fin 2→Fin 2→PositiveMatrixMeasure T (n×m))
+    (hdom : ∀ i j, (M i j).traceMeasure ≪ (@Measure.map Ω T mΩ _ t ν))
+    (hleft : ∀ i r s, MeasurableSet s →
+      (∑ j, (Matrix.trace ((probePOVM r ⊗ₖ (1 : Mat m))*(M i j).value s)).re)=
+        ν.real (a i r∩t⁻¹' s))
+    (hright : ∀ j g s, MeasurableSet s →
+      (∑ i, (Matrix.trace (((1 : Mat n) ⊗ₖ probePOVM g)*(M i j).value s)).re)=
+        ν.real (q j g∩t⁻¹' s))
+    (hjoint : ∀ i j r g s, MeasurableSet s →
+      (Matrix.trace ((probePOVM r ⊗ₖ probePOVM g)*(M i j).value s)).re=
+        ν.real ((a i r∩q j g)∩t⁻¹' s))
+    {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+    {ι : Type*} (b : HilbertBasis ι ℂ H)
+    (R : Mat (n×m)) (hR : Represented R) (i₀ : n×m)
+    (x : (n×m)→H) (hxGram : ∀ i j, inner ℂ (x i) (x j)=Rᵀ i j)
+    (W : Fin 2→Fin 2→PositiveHilbertMeasure T H b)
+    (hW : ∀ i j s, MeasurableSet s → (W i j).value s=
+      hilbertEmbed (fun k => (Real.sqrt ((Fintype.card n : ℝ)*Fintype.card m) : ℂ) • x k)
+        ((M i j).value s))
+    (hW1 : (∑ i, ∑ j, hilbertTrace b ((W i j).value Set.univ))=1)
+    (σ : PositiveHilbertMeasure T H b) (hσ1 : σ.traceMeasure Set.univ=1) :
+    ENNReal.ofReal (1/5) ≤ hilbertCQDistance b W σ := by
+  let c : ℝ≥0 := Fintype.card (n×m)
+  let N := fun i j => (M i j).scale (c : ℝ) (NNReal.coe_nonneg c)
+  apply arbitrary_purification_tested_gap (c•ν) t ht hA hB
+    (condIndep_rescale ht.comap_le hA hB hind c) a q ha hq N
+    ?_ ?_ ?_ ?_ b R hR i₀ x hxGram W ?_ hW1 σ hσ1
+  · intro i j
+    rw [Measure.map_smul c ht.aemeasurable]
+    exact (M i j).scale_domination (hdom i j) c
+  · intro i r s hs
+    simp only [N,PositiveMatrixMeasure.scale_born,← Finset.mul_sum,
+      hleft i r s hs,measureReal_nnreal_smul_apply]
+  · intro j g s hs
+    simp only [N,PositiveMatrixMeasure.scale_born,← Finset.mul_sum,
+      hright j g s hs,measureReal_nnreal_smul_apply]
+  · intro i j r g s hs
+    simp only [N,PositiveMatrixMeasure.scale_born,hjoint i j r g s hs,
+      measureReal_nnreal_smul_apply]
+  · intro i j s hs
+    rw [hW i j s hs]
+    have he : (Real.sqrt ((Fintype.card n : ℝ)*Fintype.card m) : ℂ)=
+        (Real.sqrt (Fintype.card (n×m) : ℝ) : ℂ) := by
+      simp only [Fintype.card_prod,Nat.cast_mul]
+    rw [he,hilbertEmbed_normalized_filter]
+    rfl
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/OperationalNorm.lean

@@ -0,0 +1,56 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open Filter
+open scoped Topology
+namespace SecretKey
+
+theorem recovered_gap_limit {E : Type*} [SeminormedAddCommGroup E]
+    {D : ℕ → Type*} [∀ k, SeminormedAddCommGroup (D k)]
+    (τ : ℕ → E) (τlim γ : E) (original : (k : ℕ) → D k)
+    (recover : (k : ℕ) → E → D k)
+    (hrec : ∀ k, recover k (τ k)=original k)
+    (hcontract : ∀ k x y, ‖recover k x-recover k y‖≤‖x-y‖)
+    (hgap : ∀ k, 1/5≤‖original k-recover k γ‖)
+    (hlim : Tendsto τ atTop (𝓝 τlim)) : 1/5≤‖τlim-γ‖ := by
+  have ht : Tendsto (fun k => ‖τ k-γ‖) atTop (𝓝 ‖τlim-γ‖) :=
+    (hlim.sub tendsto_const_nhds).norm
+  apply ge_of_tendsto ht
+  exact Filter.Eventually.of_forall fun k => (hgap k).trans (by simpa only [hrec] using hcontract k (τ k) γ)
+
+theorem abort_replacement_bound {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℝ E]
+    (δ : ℝ) (hδ0 : 0≤δ) (hδ1 : δ≤1) (ok bad γ : E)
+    (hstates : ‖bad-γ‖≤2) :
+    ‖((1-δ) • ok+δ • bad)-γ‖≤(1-δ)*‖ok-γ‖+2*δ := by
+  have he : ((1-δ) • ok+δ • bad)-γ=(1-δ) • (ok-γ)+δ • (bad-γ) := by
+    module
+  rw [he]
+  calc
+    _≤‖(1-δ) • (ok-γ)‖+‖δ • (bad-γ)‖ := norm_add_le _ _
+    _=(1-δ)*‖ok-γ‖+δ*‖bad-γ‖ := by
+      rw [norm_smul,norm_smul,Real.norm_eq_abs,Real.norm_eq_abs,
+        abs_of_nonneg (sub_nonneg.mpr hδ1),abs_of_nonneg hδ0]
+    _≤(1-δ)*‖ok-γ‖+2*δ := by nlinarith
+
+theorem vanishing_abort_contradicts_gap (δ error replaced : ℕ → ℝ)
+    (hδ0 : ∀ k, 0≤δ k) (hδ1 : ∀ k, δ k≤1) (he0 : ∀ k, 0≤error k)
+    (hbound : ∀ k, replaced k≤(1-δ k)*error k+2*δ k)
+    (hgap : ∀ k, 1/5≤replaced k)
+    (hδ : Tendsto δ atTop (𝓝 0)) (he : Tendsto error atTop (𝓝 0)) : False := by
+  have herror : Tendsto (fun k => (1-δ k)*error k) atTop (𝓝 0) :=
+    squeeze_zero
+      (fun k => mul_nonneg (sub_nonneg.mpr (hδ1 k)) (he0 k))
+      (fun k => mul_le_of_le_one_left (he0 k) (sub_le_self _ (hδ0 k))) he
+  have ht : Tendsto (fun k => (1-δ k)*error k+2*δ k) atTop (𝓝 0) := by
+    simpa using herror.add (hδ.const_mul 2)
+  have hh : (1:ℝ)/5≤0 := ge_of_tendsto ht
+    (Filter.Eventually.of_forall fun k => (hgap k).trans (hbound k))
+  norm_num at hh
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ParityData.lean

@@ -0,0 +1,53 @@
+import OAI.InformationTheory.Entanglement.ProjectionData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Kronecker
+open Matrix
+namespace FiniteConstruction
+open ChannelCompletion
+abbrev Four := Fin 2 × Fin 2
+abbrev Outcome := Fin 2 × Fin 2
+def XQ : Matrix (Fin 2) (Fin 2) ℚ := !![0,1;1,0]
+def ZQ : Matrix (Fin 2) (Fin 2) ℚ := !![1,0;0,-1]
+def JQ : Matrix (Fin 2) (Fin 2) ℚ := !![0,-1;1,0]
+def squareQ : Fin 3 → Fin 3 → Matrix Four Four ℚ :=
+  ![![XQ ⊗ₖ 1,1 ⊗ₖ XQ,XQ ⊗ₖ XQ],
+    ![1 ⊗ₖ ZQ,ZQ ⊗ₖ 1,ZQ ⊗ₖ ZQ],
+    ![XQ ⊗ₖ ZQ,ZQ ⊗ₖ XQ,-(JQ ⊗ₖ JQ)]]
+def contextQ : Fin 6 → Fin 3 → Matrix Four Four ℚ :=
+  ![squareQ 0,squareQ 1,squareQ 2,
+    (fun i => squareQ i 0),(fun i => squareQ i 1),(fun i => squareQ i 2)]
+def signQ (i : Fin 2) : ℚ := if i=0 then -1 else 1
+def eQ (t : Fin 6) : ℚ := if t=5 then -1 else 1
+def hQ (t : Fin 6) (a : Outcome) : Matrix Four Four ℚ :=
+  (1/4 : ℚ) • ((1+signQ a.1 • contextQ t 0)*(1+signQ a.2 • contextQ t 1))
+def eigSignQ (t : Fin 6) (a : Outcome) : Fin 3 → ℚ :=
+  ![signQ a.1,signQ a.2,eQ t*signQ a.1*signQ a.2]
+
+lemma hQ_symmetric (t : Fin 6) (a : Outcome) : (hQ t a)ᵀ=hQ t a := by
+  revert t a
+  decide +kernel
+lemma hQ_idempotent (t : Fin 6) (a : Outcome) : hQ t a*hQ t a=hQ t a := by
+  revert t a
+  decide +kernel
+lemma hQ_orthogonal (t : Fin 6) (a b : Outcome) (hab : a ≠ b) : hQ t a*hQ t b=0 := by
+  revert t a b
+  decide +kernel
+lemma hQ_complete (t : Fin 6) : ∑ a, hQ t a=1 := by
+  revert t
+  decide +kernel
+lemma hQ_eigen (t : Fin 6) (a : Outcome) (j : Fin 3) :
+    contextQ t j*hQ t a=eigSignQ t a j • hQ t a := by
+  revert t a j
+  decide +kernel
+
+def h (t : Fin 6) (a : Outcome) : Mat Four := (hQ t a).map (Rat.castHom ℂ)
+def context (t : Fin 6) (j : Fin 3) : Mat Four := (contextQ t j).map (Rat.castHom ℂ)
+def eigSign (t : Fin 6) (a : Outcome) (j : Fin 3) : ℂ := eigSignQ t a j
+end FiniteConstruction
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ParityObstruction.lean

@@ -0,0 +1,117 @@
+import OAI.InformationTheory.Entanglement.ParityData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Kronecker
+open Matrix
+namespace FiniteConstruction
+open ChannelCompletion
+lemma ratMatrix_smul (c : ℚ) (A : Matrix Four Four ℚ) :
+    (c • A).map (Rat.castHom ℂ)=(c : ℂ) • A.map (Rat.castHom ℂ) := by
+  ext i j
+  simp
+lemma h_real (t : Fin 6) (a : Outcome) (i j : Four) : star (h t a i j)=h t a i j := by
+  simp [h]
+lemma h_hermitian (t : Fin 6) (a : Outcome) : (h t a).IsHermitian := by
+  ext i j
+  rw [Matrix.conjTranspose_apply,h_real]
+  exact congrArg (fun A : Matrix Four Four ℚ => ((A i j : ℚ) : ℂ)) (hQ_symmetric t a)
+lemma h_idempotent (t : Fin 6) (a : Outcome) : h t a*h t a=h t a := by
+  simpa only [Matrix.map_mul,h] using congrArg (fun A : Matrix Four Four ℚ => A.map (Rat.castHom ℂ)) (hQ_idempotent t a)
+lemma h_orthogonal (t : Fin 6) (a b : Outcome) (hab : a ≠ b) : h t a*h t b=0 := by
+  unfold h
+  rw [← Matrix.map_mul,hQ_orthogonal t a b hab]
+  ext i j
+  simp
+lemma h_complete (t : Fin 6) : ∑ a, h t a=1 := by
+  ext i j
+  have he := congrArg (fun A : Matrix Four Four ℚ => ((A i j : ℚ) : ℂ)) (hQ_complete t)
+  by_cases hij : i=j <;> simpa [h,Matrix.sum_apply,Matrix.one_apply,hij] using he
+lemma h_eigen (t : Fin 6) (a : Outcome) (j : Fin 3) :
+    context t j*h t a=eigSign t a j • h t a := by
+  simpa only [Matrix.map_mul,ratMatrix_smul,h,context,eigSign] using
+    congrArg (fun A : Matrix Four Four ℚ => A.map (Rat.castHom ℂ)) (hQ_eigen t a j)
+lemma contextQ_symmetric (t : Fin 6) (j : Fin 3) : (contextQ t j)ᵀ=contextQ t j := by
+  revert t j
+  decide +kernel
+lemma context_hermitian (t : Fin 6) (j : Fin 3) : (context t j).IsHermitian := by
+  ext i k
+  change star ((contextQ t j k i : ℚ) : ℂ)=((contextQ t j i k : ℚ) : ℂ)
+  simp only [star_ratCast]
+  exact congrArg (fun A : Matrix Four Four ℚ => ((A i k : ℚ) : ℂ)) (contextQ_symmetric t j)
+lemma h_eigen_right (t : Fin 6) (a : Outcome) (j : Fin 3) :
+    h t a*context t j=eigSign t a j • h t a := by
+  have he := congrArg Matrix.conjTranspose (h_eigen t a j)
+  simpa only [Matrix.conjTranspose_mul,(h_hermitian t a).eq,(context_hermitian t j).eq,
+    Matrix.conjTranspose_smul,eigSign,star_ratCast] using he
+lemma shared_context (r c : Fin 3) : context (Fin.castLE (by decide) r) c=
+    context ⟨3+c.val,by omega⟩ r := by
+  have he : contextQ (Fin.castLE (by decide) r) c = contextQ ⟨3+c.val,by omega⟩ r := by
+    revert r c
+    decide +kernel
+  exact congrArg (fun A : Matrix Four Four ℚ => A.map (Rat.castHom ℂ)) he
+lemma eigSignQ_product (t : Fin 6) (a : Outcome) :
+    eigSignQ t a 0*eigSignQ t a 1*eigSignQ t a 2=eQ t := by
+  revert t a
+  decide +kernel
+lemma eigSign_product (t : Fin 6) (a : Outcome) :
+    eigSign t a 0*eigSign t a 1*eigSign t a 2=(eQ t : ℂ) := by
+  unfold eigSign
+  exact_mod_cast eigSignQ_product t a
+
+theorem parity_zero_product (a : Fin 6 → Outcome) :
+    ∃ t u : Fin 6, t ≠ u ∧ h t (a t)*h u (a u)=0 := by
+  by_contra hn
+  push Not at hn
+  have consistent (r c : Fin 3) :
+      eigSign (Fin.castLE (by decide) r) (a (Fin.castLE (by decide) r)) c=
+      eigSign ⟨3+c.val,by omega⟩ (a ⟨3+c.val,by omega⟩) r := by
+    let t : Fin 6 := Fin.castLE (by decide) r
+    let u : Fin 6 := ⟨3+c.val,by omega⟩
+    have hne : t ≠ u := by intro he; have := congrArg Fin.val he; dsimp [t,u] at this; omega
+    have he : (eigSign t (a t) c-eigSign u (a u) r) • (h t (a t)*h u (a u))=0 := by
+      rw [sub_smul,← Matrix.smul_mul,← h_eigen_right,Matrix.mul_assoc,
+        shared_context, h_eigen, Matrix.mul_smul,sub_self]
+    exact sub_eq_zero.mp ((smul_eq_zero.mp he).resolve_right (hn t u hne))
+  have row :
+      (eigSign 0 (a 0) 0*eigSign 0 (a 0) 1*eigSign 0 (a 0) 2)*
+      (eigSign 1 (a 1) 0*eigSign 1 (a 1) 1*eigSign 1 (a 1) 2)*
+      (eigSign 2 (a 2) 0*eigSign 2 (a 2) 1*eigSign 2 (a 2) 2)=1 := by
+    rw [eigSign_product,eigSign_product,eigSign_product]
+    norm_num [eQ,Fin.ext_iff]
+  have col :
+      (eigSign 3 (a 3) 0*eigSign 3 (a 3) 1*eigSign 3 (a 3) 2)*
+      (eigSign 4 (a 4) 0*eigSign 4 (a 4) 1*eigSign 4 (a 4) 2)*
+      (eigSign 5 (a 5) 0*eigSign 5 (a 5) 1*eigSign 5 (a 5) 2)=-1 := by
+    rw [eigSign_product,eigSign_product,eigSign_product]
+    norm_num [eQ,Fin.ext_iff]
+  have hc0 (r : Fin 3) := consistent r 0
+  have hc1 (r : Fin 3) := consistent r 1
+  have hc2 (r : Fin 3) := consistent r 2
+  simp only [show (⟨3+(0:Fin 3).val,by omega⟩ : Fin 6)=3 by rfl] at hc0
+  simp only [show (⟨3+(1:Fin 3).val,by omega⟩ : Fin 6)=4 by rfl] at hc1
+  simp only [show (⟨3+(2:Fin 3).val,by omega⟩ : Fin 6)=5 by rfl] at hc2
+  have h00 := hc0 0
+  have h01 := hc1 0
+  have h02 := hc2 0
+  have h10 := hc0 1
+  have h11 := hc1 1
+  have h12 := hc2 1
+  have h20 := hc0 2
+  have h21 := hc1 2
+  have h22 := hc2 2
+  have ce0 : Fin.castLE (show 3≤6 by decide) (0:Fin 3)=(0:Fin 6) := by decide
+  have ce1 : Fin.castLE (show 3≤6 by decide) (1:Fin 3)=(1:Fin 6) := by decide
+  have ce2 : Fin.castLE (show 3≤6 by decide) (2:Fin 3)=(2:Fin 6) := by decide
+  simp only [ce0,ce1,ce2] at h00 h01 h02 h10 h11 h12 h20 h21 h22
+  rw [h00,h01,h02,h10,h11,h12,h20,h21,h22] at row
+  have he : (2:ℂ)=0 := by
+    linear_combination -row+col
+  norm_num at he
+
+end FiniteConstruction
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalAdaptiveStep.lean

@@ -0,0 +1,88 @@
+import OAI.InformationTheory.Entanglement.PhysicalVersion
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+
+theorem physical_history_kernel_eq (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (G : S→TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis c d) X)
+    (hG : ∀ h s, MeasurableSet s → IsLeftTraceAction b c d ((J h).event s) ((G h).event s))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (R : S→DensityOperator (tensorHilbertBasis b d))
+    (μ : Measure S)
+    (hR : R=ᵐ[μ](fun h => densityTensor b d (ρ h) (σ h)))
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (hmg : ∀ V, MeasurableSet V → Measurable (fun h => (G h).outcome (R h) V)) :
+    TraceInstrument.historyKernel G R hmg=ᵐ[μ]TraceInstrument.historyKernel J ρ hm := by
+  filter_upwards [hR] with h hh
+  change (G h).outcome (R h)=(J h).outcome (ρ h)
+  rw [hh]
+  exact physical_product_outcome b c d (J h) (G h) (hG h) (ρ h) (σ h)
+
+theorem physical_adaptive_prefix (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (G : S→TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis c d) X)
+    (hG : ∀ h s, MeasurableSet s → IsLeftTraceAction b c d ((J h).event s) ((G h).event s))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (R : S→DensityOperator (tensorHilbertBasis b d))
+    (μ : Measure S) [IsProbabilityMeasure μ]
+    (hR : R=ᵐ[μ](fun h => densityTensor b d (ρ h) (σ h)))
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (hmg : ∀ V, MeasurableSet V → Measurable (fun h => (G h).outcome (R h) V))
+    (U : ∀ h, (G h).ConditionalUpdate (R h))
+    (V : ∀ h, (J h).ConditionalUpdate (ρ h))
+    (hf : ∀ x y, Measurable (fun p : S×X => inner ℂ x (((U p.1).state p.2).val.val y)))
+    (hp : ∀ x y, Measurable (fun p : S×X => inner ℂ x
+      ((densityTensor c d ((V p.1).state p.2) (σ p.1)).val.val y)))
+    (T : DensityOperator (tensorHilbertBasis c d))
+    (hmean : ∀ x y, inner ℂ x (T.val.val y)=∫ p, inner ℂ x (((U p.1).state p.2).val.val y)
+      ∂(μ ⊗ₘ TraceInstrument.historyKernel G R hmg)) :
+    (μ ⊗ₘ TraceInstrument.historyKernel G R hmg)=
+        (μ ⊗ₘ TraceInstrument.historyKernel J ρ hm) ∧
+    (fun p : S×X => (U p.1).state p.2)=ᵐ[μ ⊗ₘ TraceInstrument.historyKernel G R hmg]
+       (fun p => densityTensor c d ((V p.1).state p.2) (σ p.1)) := by
+  have hk := physical_history_kernel_eq b c d J G hG ρ σ R μ hR hm hmg
+  have hμ := Measure.compProd_congr hk
+  refine ⟨hμ,?_⟩
+  rw [hμ] at hmean ⊢
+  let ν := μ ⊗ₘ TraceInstrument.historyKernel J ρ hm
+  let f := fun p : S×X => (U p.1).state p.2
+  let q := fun p : S×X => densityTensor c d ((V p.1).state p.2) (σ p.1)
+  apply weak_density_ae_unique (tensorHilbertBasis c d) ν f q T hf hp hmean
+  intro Z hZ x y
+  have hfi := density_coefficient_integrable (tensorHilbertBasis c d) ν f hf x y
+  have hqi := density_coefficient_integrable (tensorHilbertBasis c d) ν q hp x y
+  have he : ν.withDensityᵥ (fun p => inner ℂ x ((f p).val.val y))=
+      ν.withDensityᵥ (fun p => inner ℂ x ((q p).val.val y)) := by
+    apply complexMeasure_ext_rectangles
+    intro A B hA hB
+    rw [withDensityᵥ_apply hfi (hA.prod hB),withDensityᵥ_apply hqi (hA.prod hB)]
+    change (∫ p in A ×ˢ B, inner ℂ x ((f p).val.val y) ∂(μ ⊗ₘ TraceInstrument.historyKernel J ρ hm))=_
+    rw [Measure.setIntegral_compProd hA hB hfi.integrableOn,
+      Measure.setIntegral_compProd hA hB hqi.integrableOn]
+    apply setIntegral_congr_ae hA
+    filter_upwards [hR] with h hh
+    intro _
+    change (∫ z in B, inner ℂ x (((U h).state z).val.val y) ∂(J h).outcome (ρ h))=_
+    have hlaw : (G h).outcome (R h)=(J h).outcome (ρ h) := by
+      rw [hh]
+      exact physical_product_outcome b c d (J h) (G h) (hG h) (ρ h) (σ h)
+    rw [← hlaw,← (U h).disintegration B hB x y,hh]
+    exact physical_disintegration_all b c d (J h) (ρ h) (σ h) (V h) hB ((G h).event B) (hG h B hB) x y
+  have hh := congrArg (fun M : ComplexMeasure (S×X) => M Z) he
+  simpa only [withDensityᵥ_apply hfi hZ,withDensityᵥ_apply hqi hZ] using hh
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalChronology.lean

@@ -0,0 +1,69 @@
+import OAI.InformationTheory.Entanglement.PhysicalExecutionStep
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H K : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+variable {ι κ X : Type*} [MeasurableSpace X]
+
+theorem physical_chronological_prefixes (b : HilbertBasis ι ℂ H) (d : HilbertBasis κ ℂ K)
+    (W : (n : ℕ)→PositiveHilbertMeasure (Fin n→X) (HilbertTensor H K) (tensorHilbertBasis b d))
+    [∀ n, IsProbabilityMeasure (W n).traceMeasure]
+    (ρ : (n : ℕ)→(Fin n→X)→DensityOperator b)
+    (σ : (n : ℕ)→(Fin n→X)→DensityOperator d)
+    (P : (n : ℕ)→Kernel (Fin n→X) X) [∀ n, IsMarkovKernel (P n)]
+    (hm : ∀ n x y, Measurable (fun h => inner ℂ x ((densityTensor b d (ρ n h) (σ n h)).val.val y)))
+    (hzero : IsWeakDensity (tensorHilbertBasis b d) (W 0) (W 0).traceMeasure
+      (fun h => densityTensor b d (ρ 0 h) (σ 0 h)))
+    (hstep : ∀ n, PhysicalExecutionStep b d (W n)
+       ((W (n+1)).mapRecord (historyStepEquiv X n) (historyStepEquiv X n).measurable)
+       (ρ n) (σ n) (ρ (n+1) ∘ (historyStepEquiv X n).symm)
+       (σ (n+1) ∘ (historyStepEquiv X n).symm) (P n)) :
+    (∀ n, IsWeakDensity (tensorHilbertBasis b d) (W n) (W n).traceMeasure
+      (fun h => densityTensor b d (ρ n h) (σ n h))) ∧
+    (∀ n, (W (n+1)).traceMeasure.map (historyStepEquiv X n)=(W n).traceMeasure ⊗ₘ P n) := by
+  have hs n (hd : IsWeakDensity (tensorHilbertBasis b d) (W n) (W n).traceMeasure
+      (fun h => densityTensor b d (ρ n h) (σ n h))) :=
+    physical_execution_step b d (W n)
+      ((W (n+1)).mapRecord (historyStepEquiv X n) (historyStepEquiv X n).measurable)
+      (ρ n) (σ n) (ρ (n+1) ∘ (historyStepEquiv X n).symm)
+      (σ (n+1) ∘ (historyStepEquiv X n).symm) (P n)
+      (hm n) (fun x y => (hm (n+1) x y).comp (historyStepEquiv X n).symm.measurable) hd (hstep n)
+  have hd n : IsWeakDensity (tensorHilbertBasis b d) (W n) (W n).traceMeasure
+      (fun h => densityTensor b d (ρ n h) (σ n h)) := by
+    induction n with
+    | zero => exact hzero
+    | succ n ih =>
+      obtain ⟨hk,hpost⟩ := hs n ih
+      apply weakDensity_of_step (tensorHilbertBasis b d) (W (n+1)) (W (n+1)).traceMeasure
+        (fun h => densityTensor b d (ρ (n+1) h) (σ (n+1) h)) (hm (n+1))
+      change IsWeakDensity (tensorHilbertBasis b d)
+        ((W (n+1)).mapRecord (historyStepEquiv X n) (historyStepEquiv X n).measurable)
+        (((W (n+1)).mapRecord (historyStepEquiv X n) (historyStepEquiv X n).measurable).traceMeasure) _
+      rw [hk]
+      exact hpost
+  exact ⟨hd,fun n => (hs n (hd n)).1⟩
+
+theorem complete_history_kernel_of_prefixes [StandardBorelSpace X] [Nonempty X]
+    (W : (n : ℕ)→Measure (Fin n→X))
+    (P : (n : ℕ)→Kernel (Fin n→X) X)
+    (hs : ∀ n, (W (n+1)).map (historyStepEquiv X n)=W n ⊗ₘ P n)
+    (ν : Measure (ℕ→X))
+    (hfull : ∀ n, ν.map (recordPrefix n)=W n) :
+    ∀ n, ν.map (fun x => (recordPrefix n x,x n))=ν.map (recordPrefix n) ⊗ₘ P n := by
+  intro n
+  have he : (fun x : ℕ→X => (recordPrefix n x,x n))=
+      (historyStepEquiv X n) ∘ recordPrefix (n+1) := rfl
+  rw [he,← Measure.map_map (historyStepEquiv X n).measurable (recordPrefix_measurable (n+1)),
+    hfull (n+1),hs n,hfull n]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalConditionalUpdate.lean

@@ -0,0 +1,87 @@
+import OAI.InformationTheory.Entanglement.WeakTensorMeasurable
+import OAI.InformationTheory.Entanglement.WeakIntegralForm
+
+namespace OAI
+
+noncomputable section
+open scoped TensorProduct InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap UniformSpace MeasureTheory
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ : Type*}
+variable {X : Type*} [MeasurableSpace X]
+lemma physical_disintegration_all (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ)
+    {s : Set X} (hs : MeasurableSet s)
+    (G : TraceClass (tensorHilbertBasis b d) →ₗ[ℂ] TraceClass (tensorHilbertBasis c d))
+    (hG : IsLeftTraceAction b c d (I.event s) G)
+    (x y : HilbertTensor K L) :
+    inner ℂ x ((G (densityTensor b d ρ σ).val).val y)=
+      ∫ z in s, inner ℂ x ((densityTensor c d (U.state z) σ).val.val y) ∂I.outcome ρ := by
+  let R := fun z => densityTensor c d (U.state z) σ
+  have hR : ∀ a a', Measurable (fun z => inner ℂ a ((R z).val.val a')) :=
+    densityTensor_coefficient_measurable c d U.state (fun _ => σ)
+      U.coefficient_measurable (fun _ _ => measurable_const)
+  let μ := (I.outcome ρ).restrict s
+  let T := (G (densityTensor b d ρ σ).val).val
+  have hI (a a') : Integrable (fun z => inner ℂ a ((R z).val.val a')) μ :=
+    density_coefficient_integrable (tensorHilbertBasis c d) μ R hR a a'
+  have hleft (a : K) (v : L) (z : HilbertTensor K L) :
+      inner ℂ z (T (hilbertTmul a v))=∫ t, inner ℂ z ((R t).val.val (hilbertTmul a v)) ∂μ := by
+    refine Completion.induction_on z (isClosed_eq (by fun_prop)
+      (densityIntegral_left_continuous (tensorHilbertBasis c d) μ R hR _)) ?_
+    intro t
+    induction t using TensorProduct.inductionOn with
+    | tmul p q => exact physical_product_disintegration b c d I ρ σ U hs G hG p a q v
+    | add p q hp hq =>
+      simp only [Completion.coe_add,inner_add_left,integral_add (hI _ _) (hI _ _),hp,hq]
+  change inner ℂ x (T y)=∫ t, inner ℂ x ((R t).val.val y) ∂μ
+  refine Completion.induction_on y (isClosed_eq (by fun_prop)
+    (densityIntegral_right_continuous (tensorHilbertBasis c d) μ R hR x)) ?_
+  intro t
+  induction t using TensorProduct.inductionOn with
+  | tmul p q => exact hleft p q x
+  | add p q hp hq =>
+    simp only [Completion.coe_add,map_add,inner_add_right,integral_add (hI _ _) (hI _ _),hp,hq]
+
+lemma physical_product_outcome (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (G : TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis c d) X)
+    (hG : ∀ s, MeasurableSet s → IsLeftTraceAction b c d (I.event s) (G.event s))
+    (ρ : DensityOperator b) (σ : DensityOperator d) :
+    G.outcome (densityTensor b d ρ σ)=I.outcome ρ := by
+  apply Measure.ext
+  intro s hs
+  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
+  change (G.outcome (densityTensor b d ρ σ)).real s=(I.outcome ρ).real s
+  rw [G.outcome_born _ hs]
+  exact physical_product_born b c d I ρ σ hs (G.event s) (hG s hs)
+
+def physical_product_update (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (G : TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis c d) X)
+    (hG : ∀ s, MeasurableSet s → IsLeftTraceAction b c d (I.event s) (G.event s))
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ) :
+    G.ConditionalUpdate (densityTensor b d ρ σ) where
+  state z := densityTensor c d (U.state z) σ
+  coefficient_measurable := densityTensor_coefficient_measurable c d U.state (fun _ => σ)
+    U.coefficient_measurable (fun _ _ => measurable_const)
+  coefficient_integrable x y := by
+    rw [physical_product_outcome b c d I G hG ρ σ]
+    exact density_coefficient_integrable (tensorHilbertBasis c d) (I.outcome ρ)
+      (fun z => densityTensor c d (U.state z) σ)
+      (densityTensor_coefficient_measurable c d U.state (fun _ => σ)
+        U.coefficient_measurable (fun _ _ => measurable_const)) x y
+  disintegration s hs x y := by
+    rw [physical_product_outcome b c d I G hG ρ σ]
+    exact physical_disintegration_all b c d I ρ σ U hs (G.event s) (hG s hs) x y
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalExecutionStep.lean

@@ -0,0 +1,96 @@
+import OAI.InformationTheory.Entanglement.PhysicalPublicPrefix
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H K : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+variable {ι κ S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+
+def IsRawInstrumentTransition (b : HilbertBasis ι ℂ H)
+    (W : PositiveHilbertMeasure S H b) (V : PositiveHilbertMeasure (S×X) H b)
+    (G : S→TraceInstrument b b X) : Prop :=
+  ∀ R : S→DensityOperator b,
+    (∀ x y, Measurable (fun h => inner ℂ x ((R h).val.val y))) →
+    IsWeakDensity b W W.traceMeasure R →
+    ∀ A B, MeasurableSet A → MeasurableSet B → ∀ x y,
+      V.coeff x y (A ×ˢ B)=∫ h in A, inner ℂ x (((G h).event B (R h).val).val y) ∂W.traceMeasure
+
+def IsRawPublicTransition (b : HilbertBasis ι ℂ H)
+    (W : PositiveHilbertMeasure S H b) (V : PositiveHilbertMeasure (S×X) H b)
+    (P : Kernel S X) : Prop :=
+  ∀ R : S→DensityOperator b,
+    (∀ x y, Measurable (fun h => inner ℂ x ((R h).val.val y))) →
+    IsWeakDensity b W W.traceMeasure R →
+    ∀ A B, MeasurableSet A → MeasurableSet B → ∀ x y,
+      V.coeff x y (A ×ˢ B)=∫ h in A, ((P h).real B : ℂ)*inner ℂ x ((R h).val.val y) ∂W.traceMeasure
+
+inductive PhysicalExecutionStep (b : HilbertBasis ι ℂ H) (d : HilbertBasis κ ℂ K)
+    (W : PositiveHilbertMeasure S (HilbertTensor H K) (tensorHilbertBasis b d))
+    (V : PositiveHilbertMeasure (S×X) (HilbertTensor H K) (tensorHilbertBasis b d))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (ρ' : S×X→DensityOperator b) (σ' : S×X→DensityOperator d) (P : Kernel S X) : Prop
+  | left
+      (J : S→TraceInstrument b b X)
+      (G : S→TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis b d) X)
+      (hG : ∀ h s, MeasurableSet s → IsLeftTraceAction b b d ((J h).event s) ((G h).event s))
+      (hm : ∀ s, MeasurableSet s → Measurable (fun h => (J h).outcome (ρ h) s))
+      (U : ∀ h, (J h).ConditionalUpdate (ρ h))
+      (hraw : IsRawInstrumentTransition (tensorHilbertBasis b d) W V G)
+      (hstateA : ρ'=fun p => (U p.1).state p.2)
+      (hstateB : σ'=σ ∘ Prod.fst)
+      (hkernel : P=TraceInstrument.historyKernel J ρ hm) :
+      PhysicalExecutionStep b d W V ρ σ ρ' σ' P
+  | right
+      (J : S→TraceInstrument d d X)
+      (G : S→TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis b d) X)
+      (hG : ∀ h s, MeasurableSet s → IsRightTraceAction d d b ((J h).event s) ((G h).event s))
+      (hm : ∀ s, MeasurableSet s → Measurable (fun h => (J h).outcome (σ h) s))
+      (U : ∀ h, (J h).ConditionalUpdate (σ h))
+      (hraw : IsRawInstrumentTransition (tensorHilbertBasis b d) W V G)
+      (hstateA : ρ'=ρ ∘ Prod.fst)
+      (hstateB : σ'=fun p => (U p.1).state p.2)
+      (hkernel : P=TraceInstrument.historyKernel J σ hm) :
+      PhysicalExecutionStep b d W V ρ σ ρ' σ' P
+  | publicDraw
+      (hraw : IsRawPublicTransition (tensorHilbertBasis b d) W V P)
+      (hstateA : ρ'=ρ ∘ Prod.fst) (hstateB : σ'=σ ∘ Prod.fst) :
+      PhysicalExecutionStep b d W V ρ σ ρ' σ' P
+variable (b : HilbertBasis ι ℂ H) (d : HilbertBasis κ ℂ K)
+
+theorem physical_execution_step
+    (W : PositiveHilbertMeasure S (HilbertTensor H K) (tensorHilbertBasis b d))
+    (V : PositiveHilbertMeasure (S×X) (HilbertTensor H K) (tensorHilbertBasis b d))
+    [IsProbabilityMeasure W.traceMeasure] [IsProbabilityMeasure V.traceMeasure]
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (ρ' : S×X→DensityOperator b) (σ' : S×X→DensityOperator d) (P : Kernel S X) [IsMarkovKernel P]
+    (hR : ∀ x y, Measurable (fun h => inner ℂ x ((densityTensor b d (ρ h) (σ h)).val.val y)))
+    (hR' : ∀ x y, Measurable (fun p => inner ℂ x ((densityTensor b d (ρ' p) (σ' p)).val.val y)))
+    (hd : IsWeakDensity (tensorHilbertBasis b d) W W.traceMeasure (fun h => densityTensor b d (ρ h) (σ h)))
+    (hstep : PhysicalExecutionStep b d W V ρ σ ρ' σ' P) :
+    V.traceMeasure=W.traceMeasure ⊗ₘ P ∧
+    IsWeakDensity (tensorHilbertBasis b d) V (W.traceMeasure ⊗ₘ P)
+      (fun p => densityTensor b d (ρ' p) (σ' p)) := by
+  cases hstep with
+  | left J G hG hm U hraw ha hb hk =>
+    subst ρ'; subst σ'; subst P
+    exact physical_raw_prefix b b d J G hG ρ σ W.traceMeasure hm U hR' V
+      (hraw _ hR hd)
+  | right J G hG hm U hraw ha hb hk =>
+    subst ρ'; subst σ'; subst P
+    exact physical_right_raw_prefix d d b J G hG σ ρ W.traceMeasure hm U hR' V
+      (hraw _ hR hd)
+  | publicDraw hraw ha hb =>
+    subst ρ'; subst σ'
+    exact physical_public_raw_prefix (tensorHilbertBasis b d) W.traceMeasure P
+      (fun h => densityTensor b d (ρ h) (σ h)) hR V (hraw _ hR hd)
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalHistoryRealization.lean

@@ -0,0 +1,53 @@
+import OAI.InformationTheory.Entanglement.PhysicalChronology
+import OAI.InformationTheory.Entanglement.CausalRealization
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory unitInterval
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter Function
+namespace SecretKey
+variable {H K : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+variable {ι κ X : Type*} [MeasurableSpace X] [StandardBorelSpace X] [Nonempty X]
+
+theorem physical_history_realization (b : HilbertBasis ι ℂ H) (d : HilbertBasis κ ℂ K)
+    (role : ℕ→TapeRole) (pub : Set ℕ) (x₀ : X)
+    (hsource : ∀ n, role n=.source → n∈pub)
+    (W : (n : ℕ)→PositiveHilbertMeasure (Fin n→X) (HilbertTensor H K) (tensorHilbertBasis b d))
+    [∀ n, IsProbabilityMeasure (W n).traceMeasure]
+    (ρ : (n : ℕ)→(Fin n→X)→DensityOperator b)
+    (τ : (n : ℕ)→(Fin n→X)→DensityOperator d)
+    (P Q : (n : ℕ)→Kernel (Fin n→X) X)
+    [∀ n, IsMarkovKernel (P n)] [∀ n, IsMarkovKernel (Q n)]
+    (hlocal : ∀ n, P n=visibleKernel role pub x₀ Q n)
+    (hm : ∀ n x y, Measurable (fun h => inner ℂ x ((densityTensor b d (ρ n h) (τ n h)).val.val y)))
+    (hzero : IsWeakDensity (tensorHilbertBasis b d) (W 0) (W 0).traceMeasure
+      (fun h => densityTensor b d (ρ 0 h) (τ 0 h)))
+    (hstep : ∀ n, PhysicalExecutionStep b d (W n)
+       ((W (n+1)).mapRecord (historyStepEquiv X n) (historyStepEquiv X n).measurable)
+       (ρ n) (τ n) (ρ (n+1) ∘ (historyStepEquiv X n).symm)
+       (τ (n+1) ∘ (historyStepEquiv X n).symm) (P n))
+    (ν : Measure (ℕ→X)) [IsProbabilityMeasure ν]
+    (hfull : ∀ n, ν.map (recordPrefix n)=(W n).traceMeasure) :
+    ∃ g : (n : ℕ)→(Fin n→X)→I→X,
+      (∀ n, Measurable (uncurry (g n))) ∧
+      ν=uniformTapesLaw.map (sampledHistory (causalSampler role pub x₀ g)) ∧
+      ∃ hT : Measurable (completeCausalPublic role pub x₀ g),
+        CondIndep ((inferInstance : MeasurableSpace (ℕ→X)).comap (completeCausalPublic role pub x₀ g))
+          (roleInfo role .alice ⊔ (inferInstance : MeasurableSpace (ℕ→X)).comap (completeCausalPublic role pub x₀ g))
+          (roleInfo role .bob ⊔ (inferInstance : MeasurableSpace (ℕ→X)).comap (completeCausalPublic role pub x₀ g))
+          hT.comap_le uniformTapesLaw := by
+  have hpre := physical_chronological_prefixes b d W ρ τ P hm hzero hstep
+  have hν := complete_history_kernel_of_prefixes (fun n => (W n).traceMeasure) P hpre.2 ν hfull
+  apply causal_history_realization role pub x₀ hsource Q ν
+  intro n
+  rw [← hlocal n]
+  exact hν n
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalProductStep.lean

@@ -0,0 +1,106 @@
+import OAI.InformationTheory.Entanglement.TraceTensor
+import OAI.InformationTheory.Entanglement.WeakProductPrefix
+
+namespace OAI
+
+noncomputable section
+open scoped TensorProduct InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap UniformSpace MeasureTheory ProbabilityTheory
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ : Type*}
+def traceTensorBilinear (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K) :
+    TraceClass b →ₗ[ℂ] TraceClass c →ₗ[ℂ] TraceClass (tensorHilbertBasis b c) where
+  toFun A :=
+    { toFun := traceTensor b c A
+      map_add' := fun B C => Subtype.ext (hilbertTensorMap_add_right A.val B.val C.val)
+      map_smul' := fun s B => Subtype.ext (hilbertTensorMap_smul_right s A.val B.val) }
+  map_add' A B := by
+    apply LinearMap.ext
+    intro C
+    apply Subtype.ext
+    exact hilbertTensorMap_add_left A.val B.val C.val
+  map_smul' s A := by
+    apply LinearMap.ext
+    intro B
+    apply Subtype.ext
+    exact hilbertTensorMap_smul_left s A.val B.val
+
+def traceTensorEmbedding (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K) :
+    TraceClass b ⊗[ℂ] TraceClass c →ₗ[ℂ] TraceClass (tensorHilbertBasis b c) :=
+  TensorProduct.lift (traceTensorBilinear b c)
+@[simp] lemma traceTensorEmbedding_tmul (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (A : TraceClass b) (B : TraceClass c) :
+    traceTensorEmbedding b c (A ⊗ₜ[ℂ] B)=traceTensor b c A B := rfl
+lemma traceTensorEmbedding_trace (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K) :
+    (traceClassTrace (tensorHilbertBasis b c)).comp (traceTensorEmbedding b c)=
+      tensorFunctional (traceClassTrace b) (traceClassTrace c) := by
+  apply TensorProduct.ext'
+  intro A B
+  exact traceTensor_trace b c A B
+lemma traceTensorEmbedding_coeff (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (x y : H) (u v : K) :
+    (traceClassCoefficient (tensorHilbertBasis b c) (hilbertTmul x u) (hilbertTmul y v)).comp
+      (traceTensorEmbedding b c)=
+      tensorFunctional (traceClassCoefficient b x y) (traceClassCoefficient c u v) := by
+  apply TensorProduct.ext'
+  intro A B
+  change inner ℂ (hilbertTmul x u) (hilbertTensorMap A.val B.val (hilbertTmul y v))=_
+  rw [hilbertTensorMap_tmul,hilbertTmul_inner]
+  rfl
+def densityTensor (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (ρ : DensityOperator b) (σ : DensityOperator c) : DensityOperator (tensorHilbertBasis b c) :=
+  ⟨traceTensor b c ρ.val σ.val,hilbertTensorMap_nonneg ρ.property.1 σ.property.1,by
+    rw [traceTensor_trace,ρ.property.2,σ.property.2,mul_one]⟩
+
+def IsLeftTraceAction (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (F : TraceClass b →ₗ[ℂ] TraceClass c)
+    (G : TraceClass (tensorHilbertBasis b d) →ₗ[ℂ] TraceClass (tensorHilbertBasis c d)) : Prop :=
+  ∀ A B, G (traceTensor b d A B)=traceTensor c d (F A) B
+lemma leftTraceAction_intertwines (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (F : TraceClass b →ₗ[ℂ] TraceClass c)
+    (G : TraceClass (tensorHilbertBasis b d) →ₗ[ℂ] TraceClass (tensorHilbertBasis c d))
+    (hG : IsLeftTraceAction b c d F G) :
+    G.comp (traceTensorEmbedding b d)=
+      (traceTensorEmbedding c d).comp (TensorProduct.map F LinearMap.id) := by
+  apply TensorProduct.ext'
+  intro A B
+  exact hG A B
+variable {X : Type*} [MeasurableSpace X]
+
+theorem physical_product_born (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) {s : Set X} (hs : MeasurableSet s)
+    (G : TraceClass (tensorHilbertBasis b d) →ₗ[ℂ] TraceClass (tensorHilbertBasis c d))
+    (hG : IsLeftTraceAction b c d (I.event s) G) :
+    (traceClassTrace (tensorHilbertBasis c d) (G (densityTensor b d ρ σ).val)).re=
+      (I.outcome ρ).real s := by
+  change (traceClassTrace (tensorHilbertBasis c d) (G (traceTensor b d ρ.val σ.val))).re=_
+  rw [hG,traceTensor_trace,σ.property.2,mul_one,I.outcome_born ρ hs]
+
+theorem physical_product_disintegration (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ)
+    {s : Set X} (hs : MeasurableSet s)
+    (G : TraceClass (tensorHilbertBasis b d) →ₗ[ℂ] TraceClass (tensorHilbertBasis c d))
+    (hG : IsLeftTraceAction b c d (I.event s) G) (x y : K) (u v : L) :
+    inner ℂ (hilbertTmul x u) ((G (densityTensor b d ρ σ).val).val (hilbertTmul y v))=
+      ∫ z in s, inner ℂ (hilbertTmul x u)
+        ((densityTensor c d (U.state z) σ).val.val (hilbertTmul y v)) ∂I.outcome ρ := by
+  change inner ℂ (hilbertTmul x u) ((G (traceTensor b d ρ.val σ.val)).val (hilbertTmul y v))=_
+  rw [hG]
+  change inner ℂ (hilbertTmul x u) (hilbertTensorMap (I.event s ρ.val).val σ.val.val (hilbertTmul y v))=_
+  rw [hilbertTensorMap_tmul,hilbertTmul_inner,U.disintegration s hs]
+  erw [← integral_mul_const]
+  apply setIntegral_congr_fun hs
+  intro z hz
+  simp [densityTensor,traceTensor,hilbertTmul_inner]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalPublicPrefix.lean

@@ -0,0 +1,45 @@
+import OAI.InformationTheory.Entanglement.PhysicalRightRawPrefix
+import OAI.InformationTheory.Entanglement.HilbertRecordMap
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+variable {ι S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+
+theorem physical_public_raw_prefix (b : HilbertBasis ι ℂ H)
+    (μ : Measure S) [IsProbabilityMeasure μ] (κ : Kernel S X) [IsMarkovKernel κ]
+    (ρ : S→DensityOperator b)
+    (hm : ∀ x y, Measurable (fun h => inner ℂ x ((ρ h).val.val y)))
+    (W : PositiveHilbertMeasure (S×X) H b) [IsProbabilityMeasure W.traceMeasure]
+    (hEvent : ∀ A B, MeasurableSet A → MeasurableSet B → ∀ x y,
+      W.coeff x y (A ×ˢ B)=∫ h in A, ((κ h).real B : ℂ)*inner ℂ x ((ρ h).val.val y) ∂μ) :
+    W.traceMeasure=μ ⊗ₘ κ ∧ IsWeakDensity b W (μ ⊗ₘ κ) (ρ ∘ Prod.fst) := by
+  let ν := μ ⊗ₘ κ
+  let f : S×X→DensityOperator b := ρ ∘ Prod.fst
+  have hf : ∀ x y, Measurable (fun p : S×X => inner ℂ x ((f p).val.val y)) :=
+    fun x y => (hm x y).comp measurable_fst
+  have hd : IsWeakDensity b W ν f := by
+    intro Z hZ x y
+    have hi := density_coefficient_integrable b ν f hf x y
+    have he : W.coeff x y=ν.withDensityᵥ (fun p => inner ℂ x ((f p).val.val y)) := by
+      apply complexMeasure_ext_rectangles
+      intro A B hA hB
+      rw [withDensityᵥ_apply hi (hA.prod hB)]
+      change W.coeff x y (A ×ˢ B)=(∫ p in A ×ˢ B, inner ℂ x ((f p).val.val y) ∂(μ ⊗ₘ κ))
+      rw [Measure.setIntegral_compProd hA hB hi.integrableOn,hEvent A B hA hB x y]
+      apply setIntegral_congr_fun hA
+      intro h hh
+      change ((κ h).real B : ℂ)*inner ℂ x ((ρ h).val.val y)=∫ _ in B, inner ℂ x ((ρ h).val.val y) ∂κ h
+      simp only [integral_const,Measure.restrict_apply_univ,Measure.real,Complex.real_smul]
+    rw [he,withDensityᵥ_apply hi hZ]
+  exact ⟨weak_density_trace_eq b W ν f hf hd,hd⟩
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalRawPrefix.lean

@@ -0,0 +1,58 @@
+import OAI.InformationTheory.Entanglement.PhysicalRightAdaptive
+import OAI.InformationTheory.Entanglement.WeakLawTrace
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+
+theorem physical_raw_prefix (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (G : S→TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis c d) X)
+    (hG : ∀ h s, MeasurableSet s → IsLeftTraceAction b c d ((J h).event s) ((G h).event s))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (μ : Measure S) [IsProbabilityMeasure μ]
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (U : ∀ h, (J h).ConditionalUpdate (ρ h))
+    (hp : ∀ x y, Measurable (fun p : S×X => inner ℂ x
+      ((densityTensor c d ((U p.1).state p.2) (σ p.1)).val.val y)))
+    (W : PositiveHilbertMeasure (S×X) (HilbertTensor K L) (tensorHilbertBasis c d))
+    [IsProbabilityMeasure W.traceMeasure]
+    (hEvent : ∀ A B, MeasurableSet A → MeasurableSet B → ∀ x y,
+      W.coeff x y (A ×ˢ B)=∫ h in A,
+        inner ℂ x (((G h).event B (densityTensor b d (ρ h) (σ h)).val).val y) ∂μ) :
+    W.traceMeasure=μ ⊗ₘ TraceInstrument.historyKernel J ρ hm ∧
+    ∀ Z, MeasurableSet Z → ∀ x y, W.coeff x y Z=
+      ∫ p in Z, inner ℂ x ((densityTensor c d ((U p.1).state p.2) (σ p.1)).val.val y)
+        ∂(μ ⊗ₘ TraceInstrument.historyKernel J ρ hm) := by
+  let ν := μ ⊗ₘ TraceInstrument.historyKernel J ρ hm
+  let f := fun p : S×X => densityTensor c d ((U p.1).state p.2) (σ p.1)
+  have hd (Z : Set (S×X)) (hZ : MeasurableSet Z) (x y : HilbertTensor K L) :
+      W.coeff x y Z=∫ p in Z, inner ℂ x ((f p).val.val y) ∂ν := by
+    have hi := density_coefficient_integrable (tensorHilbertBasis c d) ν f hp x y
+    have he : W.coeff x y=ν.withDensityᵥ (fun p => inner ℂ x ((f p).val.val y)) := by
+      apply complexMeasure_ext_rectangles
+      intro A B hA hB
+      rw [withDensityᵥ_apply hi (hA.prod hB)]
+      change W.coeff x y (A ×ˢ B)=(∫ p in A ×ˢ B, inner ℂ x ((f p).val.val y)
+        ∂(μ ⊗ₘ TraceInstrument.historyKernel J ρ hm))
+      rw [Measure.setIntegral_compProd hA hB hi.integrableOn,hEvent A B hA hB x y]
+      apply setIntegral_congr_fun hA
+      intro h hh
+      exact physical_disintegration_all b c d (J h) (ρ h) (σ h) (U h) hB
+        ((G h).event B) (hG h B hB) x y
+    rw [he,withDensityᵥ_apply hi hZ]
+  exact ⟨weak_density_trace_eq (tensorHilbertBasis c d) W ν f hp hd,hd⟩
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalRightAdaptive.lean

@@ -0,0 +1,88 @@
+import OAI.InformationTheory.Entanglement.PhysicalRightStep
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+
+theorem physical_right_history_kernel_eq (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (G : S→TraceInstrument (tensorHilbertBasis d b) (tensorHilbertBasis d c) X)
+    (hG : ∀ h s, MeasurableSet s → IsRightTraceAction b c d ((J h).event s) ((G h).event s))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (R : S→DensityOperator (tensorHilbertBasis d b))
+    (μ : Measure S)
+    (hR : R=ᵐ[μ](fun h => densityTensor d b (σ h) (ρ h)))
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (hmg : ∀ V, MeasurableSet V → Measurable (fun h => (G h).outcome (R h) V)) :
+    TraceInstrument.historyKernel G R hmg=ᵐ[μ]TraceInstrument.historyKernel J ρ hm := by
+  filter_upwards [hR] with h hh
+  change (G h).outcome (R h)=(J h).outcome (ρ h)
+  rw [hh]
+  exact physical_right_outcome b c d (J h) (G h) (hG h) (ρ h) (σ h)
+
+theorem physical_right_adaptive_prefix (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (G : S→TraceInstrument (tensorHilbertBasis d b) (tensorHilbertBasis d c) X)
+    (hG : ∀ h s, MeasurableSet s → IsRightTraceAction b c d ((J h).event s) ((G h).event s))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (R : S→DensityOperator (tensorHilbertBasis d b))
+    (μ : Measure S) [IsProbabilityMeasure μ]
+    (hR : R=ᵐ[μ](fun h => densityTensor d b (σ h) (ρ h)))
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (hmg : ∀ V, MeasurableSet V → Measurable (fun h => (G h).outcome (R h) V))
+    (U : ∀ h, (G h).ConditionalUpdate (R h))
+    (V : ∀ h, (J h).ConditionalUpdate (ρ h))
+    (hf : ∀ x y, Measurable (fun p : S×X => inner ℂ x (((U p.1).state p.2).val.val y)))
+    (hp : ∀ x y, Measurable (fun p : S×X => inner ℂ x
+      ((densityTensor d c (σ p.1) ((V p.1).state p.2)).val.val y)))
+    (T : DensityOperator (tensorHilbertBasis d c))
+    (hmean : ∀ x y, inner ℂ x (T.val.val y)=∫ p, inner ℂ x (((U p.1).state p.2).val.val y)
+      ∂(μ ⊗ₘ TraceInstrument.historyKernel G R hmg)) :
+    (μ ⊗ₘ TraceInstrument.historyKernel G R hmg)=
+        (μ ⊗ₘ TraceInstrument.historyKernel J ρ hm) ∧
+    (fun p : S×X => (U p.1).state p.2)=ᵐ[μ ⊗ₘ TraceInstrument.historyKernel G R hmg]
+       (fun p => densityTensor d c (σ p.1) ((V p.1).state p.2)) := by
+  have hk := physical_right_history_kernel_eq b c d J G hG ρ σ R μ hR hm hmg
+  have hμ := Measure.compProd_congr hk
+  refine ⟨hμ,?_⟩
+  rw [hμ] at hmean ⊢
+  let ν := μ ⊗ₘ TraceInstrument.historyKernel J ρ hm
+  let f := fun p : S×X => (U p.1).state p.2
+  let q := fun p : S×X => densityTensor d c (σ p.1) ((V p.1).state p.2)
+  apply weak_density_ae_unique (tensorHilbertBasis d c) ν f q T hf hp hmean
+  intro Z hZ x y
+  have hfi := density_coefficient_integrable (tensorHilbertBasis d c) ν f hf x y
+  have hqi := density_coefficient_integrable (tensorHilbertBasis d c) ν q hp x y
+  have he : ν.withDensityᵥ (fun p => inner ℂ x ((f p).val.val y))=
+      ν.withDensityᵥ (fun p => inner ℂ x ((q p).val.val y)) := by
+    apply complexMeasure_ext_rectangles
+    intro A B hA hB
+    rw [withDensityᵥ_apply hfi (hA.prod hB),withDensityᵥ_apply hqi (hA.prod hB)]
+    change (∫ p in A ×ˢ B, inner ℂ x ((f p).val.val y) ∂(μ ⊗ₘ TraceInstrument.historyKernel J ρ hm))=_
+    rw [Measure.setIntegral_compProd hA hB hfi.integrableOn,
+      Measure.setIntegral_compProd hA hB hqi.integrableOn]
+    apply setIntegral_congr_ae hA
+    filter_upwards [hR] with h hh
+    intro _
+    change (∫ z in B, inner ℂ x (((U h).state z).val.val y) ∂(J h).outcome (ρ h))=_
+    have hlaw : (G h).outcome (R h)=(J h).outcome (ρ h) := by
+      rw [hh]
+      exact physical_right_outcome b c d (J h) (G h) (hG h) (ρ h) (σ h)
+    rw [← hlaw,← (U h).disintegration B hB x y,hh]
+    exact physical_right_disintegration_all b c d (J h) (ρ h) (σ h) (V h) hB ((G h).event B) (hG h B hB) x y
+  have hh := congrArg (fun M : ComplexMeasure (S×X) => M Z) he
+  simpa only [withDensityᵥ_apply hfi hZ,withDensityᵥ_apply hqi hZ] using hh
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalRightRawPrefix.lean

@@ -0,0 +1,57 @@
+import OAI.InformationTheory.Entanglement.PhysicalRawPrefix
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory ProbabilityTheory Filter
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+
+theorem physical_right_raw_prefix (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (G : S→TraceInstrument (tensorHilbertBasis d b) (tensorHilbertBasis d c) X)
+    (hG : ∀ h s, MeasurableSet s → IsRightTraceAction b c d ((J h).event s) ((G h).event s))
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (μ : Measure S) [IsProbabilityMeasure μ]
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (U : ∀ h, (J h).ConditionalUpdate (ρ h))
+    (hp : ∀ x y, Measurable (fun p : S×X => inner ℂ x
+      ((densityTensor d c (σ p.1) ((U p.1).state p.2)).val.val y)))
+    (W : PositiveHilbertMeasure (S×X) (HilbertTensor L K) (tensorHilbertBasis d c))
+    [IsProbabilityMeasure W.traceMeasure]
+    (hEvent : ∀ A B, MeasurableSet A → MeasurableSet B → ∀ x y,
+      W.coeff x y (A ×ˢ B)=∫ h in A,
+        inner ℂ x (((G h).event B (densityTensor d b (σ h) (ρ h)).val).val y) ∂μ) :
+    W.traceMeasure=μ ⊗ₘ TraceInstrument.historyKernel J ρ hm ∧
+    ∀ Z, MeasurableSet Z → ∀ x y, W.coeff x y Z=
+      ∫ p in Z, inner ℂ x ((densityTensor d c (σ p.1) ((U p.1).state p.2)).val.val y)
+        ∂(μ ⊗ₘ TraceInstrument.historyKernel J ρ hm) := by
+  let ν := μ ⊗ₘ TraceInstrument.historyKernel J ρ hm
+  let f := fun p : S×X => densityTensor d c (σ p.1) ((U p.1).state p.2)
+  have hd (Z : Set (S×X)) (hZ : MeasurableSet Z) (x y : HilbertTensor L K) :
+      W.coeff x y Z=∫ p in Z, inner ℂ x ((f p).val.val y) ∂ν := by
+    have hi := density_coefficient_integrable (tensorHilbertBasis d c) ν f hp x y
+    have he : W.coeff x y=ν.withDensityᵥ (fun p => inner ℂ x ((f p).val.val y)) := by
+      apply complexMeasure_ext_rectangles
+      intro A B hA hB
+      rw [withDensityᵥ_apply hi (hA.prod hB)]
+      change W.coeff x y (A ×ˢ B)=(∫ p in A ×ˢ B, inner ℂ x ((f p).val.val y)
+        ∂(μ ⊗ₘ TraceInstrument.historyKernel J ρ hm))
+      rw [Measure.setIntegral_compProd hA hB hi.integrableOn,hEvent A B hA hB x y]
+      apply setIntegral_congr_fun hA
+      intro h hh
+      exact physical_right_disintegration_all b c d (J h) (ρ h) (σ h) (U h) hB
+        ((G h).event B) (hG h B hB) x y
+    rw [he,withDensityᵥ_apply hi hZ]
+  exact ⟨weak_density_trace_eq (tensorHilbertBasis d c) W ν f hp hd,hd⟩
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalRightStep.lean

@@ -0,0 +1,117 @@
+import OAI.InformationTheory.Entanglement.PhysicalAdaptiveStep
+
+namespace OAI
+
+noncomputable section
+open scoped TensorProduct InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap UniformSpace MeasureTheory ProbabilityTheory
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ : Type*}
+
+def IsRightTraceAction (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (F : TraceClass b →ₗ[ℂ] TraceClass c)
+    (G : TraceClass (tensorHilbertBasis d b) →ₗ[ℂ] TraceClass (tensorHilbertBasis d c)) : Prop :=
+  ∀ A B, G (traceTensor d b B A)=traceTensor d c B (F A)
+variable {X : Type*} [MeasurableSpace X]
+lemma physical_right_born (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) {s : Set X} (hs : MeasurableSet s)
+    (G : TraceClass (tensorHilbertBasis d b) →ₗ[ℂ] TraceClass (tensorHilbertBasis d c))
+    (hG : IsRightTraceAction b c d (I.event s) G) :
+    (traceClassTrace (tensorHilbertBasis d c) (G (densityTensor d b σ ρ).val)).re=
+      (I.outcome ρ).real s := by
+  change (traceClassTrace (tensorHilbertBasis d c) (G (traceTensor d b σ.val ρ.val))).re=_
+  rw [hG,traceTensor_trace,σ.property.2,one_mul,I.outcome_born ρ hs]
+lemma physical_right_disintegration (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ)
+    {s : Set X} (hs : MeasurableSet s)
+    (G : TraceClass (tensorHilbertBasis d b) →ₗ[ℂ] TraceClass (tensorHilbertBasis d c))
+    (hG : IsRightTraceAction b c d (I.event s) G) (x y : K) (u v : L) :
+    inner ℂ (hilbertTmul u x) ((G (densityTensor d b σ ρ).val).val (hilbertTmul v y))=
+      ∫ z in s, inner ℂ (hilbertTmul u x)
+        ((densityTensor d c σ (U.state z)).val.val (hilbertTmul v y)) ∂I.outcome ρ := by
+  change inner ℂ (hilbertTmul u x) ((G (traceTensor d b σ.val ρ.val)).val (hilbertTmul v y))=_
+  rw [hG]
+  change inner ℂ (hilbertTmul u x) (hilbertTensorMap σ.val.val (I.event s ρ.val).val (hilbertTmul v y))=_
+  rw [hilbertTensorMap_tmul,hilbertTmul_inner,U.disintegration s hs]
+  erw [← integral_const_mul]
+  apply setIntegral_congr_fun hs
+  intro z hz
+  simp [densityTensor,traceTensor,hilbertTmul_inner]
+lemma physical_right_disintegration_all (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ)
+    {s : Set X} (hs : MeasurableSet s)
+    (G : TraceClass (tensorHilbertBasis d b) →ₗ[ℂ] TraceClass (tensorHilbertBasis d c))
+    (hG : IsRightTraceAction b c d (I.event s) G)
+    (x y : HilbertTensor L K) :
+    inner ℂ x ((G (densityTensor d b σ ρ).val).val y)=
+      ∫ z in s, inner ℂ x ((densityTensor d c σ (U.state z)).val.val y) ∂I.outcome ρ := by
+  let R := fun z => densityTensor d c σ (U.state z)
+  have hR : ∀ a a', Measurable (fun z => inner ℂ a ((R z).val.val a')) :=
+    densityTensor_coefficient_measurable d c (fun _ => σ) U.state
+      (fun _ _ => measurable_const) U.coefficient_measurable
+  let μ := (I.outcome ρ).restrict s
+  let T := (G (densityTensor d b σ ρ).val).val
+  have hI (a a') : Integrable (fun z => inner ℂ a ((R z).val.val a')) μ :=
+    density_coefficient_integrable (tensorHilbertBasis d c) μ R hR a a'
+  have hleft (a : L) (v : K) (z : HilbertTensor L K) :
+      inner ℂ z (T (hilbertTmul a v))=∫ t, inner ℂ z ((R t).val.val (hilbertTmul a v)) ∂μ := by
+    refine Completion.induction_on z (isClosed_eq (by fun_prop)
+      (densityIntegral_left_continuous (tensorHilbertBasis d c) μ R hR _)) ?_
+    intro t
+    induction t using TensorProduct.inductionOn with
+    | tmul p q => exact physical_right_disintegration b c d I ρ σ U hs G hG q v p a
+    | add p q hp hq =>
+      simp only [Completion.coe_add,inner_add_left,integral_add (hI _ _) (hI _ _),hp,hq]
+  change inner ℂ x (T y)=∫ t, inner ℂ x ((R t).val.val y) ∂μ
+  refine Completion.induction_on y (isClosed_eq (by fun_prop)
+    (densityIntegral_right_continuous (tensorHilbertBasis d c) μ R hR x)) ?_
+  intro t
+  induction t using TensorProduct.inductionOn with
+  | tmul p q => exact hleft p q x
+  | add p q hp hq =>
+    simp only [Completion.coe_add,map_add,inner_add_right,integral_add (hI _ _) (hI _ _),hp,hq]
+
+lemma physical_right_outcome (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (G : TraceInstrument (tensorHilbertBasis d b) (tensorHilbertBasis d c) X)
+    (hG : ∀ s, MeasurableSet s → IsRightTraceAction b c d (I.event s) (G.event s))
+    (ρ : DensityOperator b) (σ : DensityOperator d) :
+    G.outcome (densityTensor d b σ ρ)=I.outcome ρ := by
+  apply Measure.ext
+  intro s hs
+  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
+  change (G.outcome (densityTensor d b σ ρ)).real s=(I.outcome ρ).real s
+  rw [G.outcome_born _ hs]
+  exact physical_right_born b c d I ρ σ hs (G.event s) (hG s hs)
+
+def physical_right_update (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (G : TraceInstrument (tensorHilbertBasis d b) (tensorHilbertBasis d c) X)
+    (hG : ∀ s, MeasurableSet s → IsRightTraceAction b c d (I.event s) (G.event s))
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ) :
+    G.ConditionalUpdate (densityTensor d b σ ρ) where
+  state z := densityTensor d c σ (U.state z)
+  coefficient_measurable := densityTensor_coefficient_measurable d c (fun _ => σ) U.state
+    (fun _ _ => measurable_const) U.coefficient_measurable
+  coefficient_integrable x y := by
+    rw [physical_right_outcome b c d I G hG ρ σ]
+    exact density_coefficient_integrable (tensorHilbertBasis d c) (I.outcome ρ)
+      (fun z => densityTensor d c σ (U.state z))
+      (densityTensor_coefficient_measurable d c (fun _ => σ) U.state
+        (fun _ _ => measurable_const) U.coefficient_measurable) x y
+  disintegration s hs x y := by
+    rw [physical_right_outcome b c d I G hG ρ σ]
+    exact physical_right_disintegration_all b c d I ρ σ U hs (G.event s) (hG s hs) x y
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PhysicalVersion.lean

@@ -0,0 +1,29 @@
+import OAI.InformationTheory.Entanglement.WeakStateUnique
+
+namespace OAI
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder MeasureTheory
+open ContinuousLinearMap MeasureTheory
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ X : Type*} [MeasurableSpace X]
+
+theorem physical_product_version (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (G : TraceInstrument (tensorHilbertBasis b d) (tensorHilbertBasis c d) X)
+    (hG : ∀ s, MeasurableSet s → IsLeftTraceAction b c d (I.event s) (G.event s))
+    (ρ : DensityOperator b) (σ : DensityOperator d) (U : I.ConditionalUpdate ρ)
+    (V : G.ConditionalUpdate (densityTensor b d ρ σ)) :
+    V.state=ᵐ[G.outcome (densityTensor b d ρ σ)]
+      (fun z => densityTensor c d (U.state z) σ) :=
+  V.ae_unique (physical_product_update b c d I G hG ρ σ U)
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PolynomialGcdDegree.lean

@@ -0,0 +1,50 @@
+import OAI.Analysis.Quantum.PPTSquare.Mod131Powers01
+import OAI.Analysis.Quantum.PPTSquare.Mod131Powers02
+import OAI.Analysis.Quantum.PPTSquare.Mod131Powers03
+import OAI.Analysis.Quantum.PPTSquare.Mod131Powers04
+import OAI.Analysis.Quantum.PPTSquare.Mod131Data
+import OAI.Analysis.Quantum.PPTSquare.Mod131Products
+import OAI.Analysis.Quantum.PPTSquare.Mod131Reduction
+import OAI.Analysis.Quantum.PPTSquare.Mod139Powers01
+import OAI.Analysis.Quantum.PPTSquare.Mod139Powers02
+import OAI.Analysis.Quantum.PPTSquare.Mod139Powers03
+import OAI.Analysis.Quantum.PPTSquare.Mod139Powers04
+import OAI.Analysis.Quantum.PPTSquare.Mod139Powers05
+import OAI.Analysis.Quantum.PPTSquare.Mod139Data
+import OAI.Analysis.Quantum.PPTSquare.Mod139Products
+import OAI.Analysis.Quantum.PPTSquare.Mod139Reduction
+import OAI.Analysis.Quantum.PPTSquare.Mod41Powers01
+import OAI.Analysis.Quantum.PPTSquare.Mod41Powers02
+import OAI.Analysis.Quantum.PPTSquare.Mod41Powers03
+import OAI.Analysis.Quantum.PPTSquare.Mod41Powers04
+import OAI.Analysis.Quantum.PPTSquare.Mod41Powers05
+import OAI.Analysis.Quantum.PPTSquare.Mod41Powers06
+import OAI.Analysis.Quantum.PPTSquare.Mod41Data
+import OAI.Analysis.Quantum.PPTSquare.Mod41Products
+import OAI.Analysis.Quantum.PPTSquare.Mod41Reduction
+import OAI.Analysis.Quantum.PPTSquare.ModularSupport
+import OAI.Analysis.Quantum.PPTSquare.GaloisAction
+
+namespace OAI
+
+open Polynomial
+noncomputable section
+namespace PolynomialGcdDegree
+attribute [local instance] Classical.propDecidable
+local instance : Fact (Nat.Prime 41) := ⟨by decide⟩
+def dg (e : ℕ) : Prop := (EuclideanDomain.gcd ModularPencil.P41.f (X^e-X)).natDegree = 0
+def dgc (e : ℕ) : Prop := by
+  classical
+  exact (EuclideanDomain.gcd ModularPencil.P41.f (X^e-X)).natDegree = 0
+lemma bridge (e n : ℕ) (h : ModularPencil.P41.degreeCert e n) :
+    (EuclideanDomain.gcd ModularPencil.P41.f (X^e-X)).natDegree = n := by
+  unfold ModularPencil.P41.degreeCert at h
+  convert h using 2
+lemma concrete : dg (41^4) := by
+  exact bridge (41^4) 0 ModularPencil.P41.gcd_degree4
+
+end PolynomialGcdDegree
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PositiveBlock.lean

@@ -0,0 +1,79 @@
+import OAI.InformationTheory.Entanglement.TraceNorm
+
+namespace OAI
+
+noncomputable section
+open scoped MatrixOrder ComplexOrder BigOperators Kronecker
+open Matrix
+namespace SecretKey
+variable {n m k : Type} [Fintype n] [Fintype m] [Fintype k]
+
+def hsVector (A : Matrix n m ℂ) : EuclideanSpace ℂ (n × m) :=
+  WithLp.toLp 2 (fun p => A p.1 p.2)
+def hsNorm (A : Matrix n m ℂ) : ℝ := ‖hsVector A‖
+
+lemma trace_mul_conj_eq_inner (A B : Matrix n m ℂ) :
+    Matrix.trace (A * Bᴴ) = inner ℂ (hsVector B) (hsVector A) := by
+  simp [Matrix.trace, Matrix.mul_apply, Matrix.conjTranspose_apply, hsVector,
+    PiLp.inner_apply, Fintype.sum_prod_type, RCLike.inner_apply]
+
+lemma hsNorm_sq (A : Matrix n m ℂ) :
+    hsNorm A ^ 2 = (Matrix.trace (A * Aᴴ)).re := by
+  rw [trace_mul_conj_eq_inner]
+  exact norm_sq_eq_re_inner (𝕜 := ℂ) _
+
+lemma trace_mul_conj_norm_le (A B : Matrix n m ℂ) :
+    ‖Matrix.trace (A * Bᴴ)‖ ≤ hsNorm A * hsNorm B := by
+  rw [trace_mul_conj_eq_inner]
+  simpa [hsNorm, mul_comm] using norm_inner_le_norm (hsVector B) (hsVector A)
+
+lemma hsNorm_unitary [DecidableEq n] {U : Matrix n n ℂ} (hU : Uᴴ * U = 1)
+    (A : Matrix n m ℂ) : hsNorm (U * A) = hsNorm A := by
+  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  change hsNorm (U * A) ^ 2 = hsNorm A ^ 2
+  rw [hsNorm_sq, hsNorm_sq, Matrix.conjTranspose_mul]
+  congr 1
+  calc
+    Matrix.trace (U * A * (Aᴴ * Uᴴ)) = Matrix.trace (U * (A * Aᴴ) * Uᴴ) := by
+      simp only [Matrix.mul_assoc]
+    _ = Matrix.trace (Uᴴ * U * (A * Aᴴ)) := Matrix.trace_mul_cycle _ _ _
+    _ = Matrix.trace (A * Aᴴ) := by rw [hU, Matrix.one_mul]
+
+lemma traceNorm_mul_conj_le [DecidableEq n] (A B : Matrix n m ℂ) :
+    traceNorm (A * Bᴴ) ≤ hsNorm A * hsNorm B := by
+  obtain ⟨U,hU,he⟩ := traceNorm_witness (A * Bᴴ)
+  rw [he, ← Matrix.mul_assoc]
+  exact (Complex.re_le_norm _).trans
+    ((trace_mul_conj_norm_le (U * A) B).trans_eq (by rw [hsNorm_unitary hU]))
+
+lemma traceNorm_mul_conj_le_sqrt [DecidableEq n] (A B : Matrix n m ℂ) :
+    traceNorm (A * Bᴴ) ≤ Real.sqrt ((Matrix.trace (A * Aᴴ)).re * (Matrix.trace (B * Bᴴ)).re) := by
+  rw [← hsNorm_sq, ← hsNorm_sq, ← mul_pow, Real.sqrt_sq_eq_abs, abs_of_nonneg (show 0 ≤ hsNorm A * hsNorm B from mul_nonneg (norm_nonneg _) (norm_nonneg _))]
+  exact traceNorm_mul_conj_le A B
+
+lemma positive_block [DecidableEq n] (H J Z : Matrix n n ℂ)
+    (h : (Matrix.fromBlocks H Z Zᴴ J).PosSemidef) :
+    traceNorm Z ≤ Real.sqrt ((Matrix.trace H).re * (Matrix.trace J).re) := by
+  let Q := CFC.sqrt (Matrix.fromBlocks H Z Zᴴ J)
+  have hQh : Qᴴ = Q :=
+    (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg _)).isHermitian.eq
+  have hQ : Q * Qᴴ = Matrix.fromBlocks H Z Zᴴ J := by
+    rw [hQh]
+    exact CFC.sqrt_mul_sqrt_self _ h.nonneg
+  let A : Matrix n (n ⊕ n) ℂ := fun i j => Q (Sum.inl i) j
+  let B : Matrix n (n ⊕ n) ℂ := fun i j => Q (Sum.inr i) j
+  have hA : A * Aᴴ = H := by
+    ext i j
+    exact congrArg (fun M => M (Sum.inl i) (Sum.inl j)) hQ
+  have hB : B * Bᴴ = J := by
+    ext i j
+    exact congrArg (fun M => M (Sum.inr i) (Sum.inr j)) hQ
+  have hZ : A * Bᴴ = Z := by
+    ext i j
+    exact congrArg (fun M => M (Sum.inl i) (Sum.inr j)) hQ
+  simpa only [hA,hB,hZ] using traceNorm_mul_conj_le_sqrt A B
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PowersStormer.lean

@@ -0,0 +1,109 @@
+import OAI.InformationTheory.Entanglement.FidelityTools
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {n : Type} [Fintype n] [DecidableEq n]
+
+omit [Fintype n] [DecidableEq n] in
+lemma psd_diagonal_real {A : Mat n} (hA : A.PosSemidef) (i : n) :
+    0≤(A i i).re := (Complex.nonneg_iff.mp (hA.diag_nonneg (i := i))).1
+
+lemma powers_stormer_diagonal {A B : Mat n} (hA : A.PosSemidef) (hB : B.PosSemidef)
+    (z : n → ℝ) (hz : A-B=Matrix.diagonal (fun i => (z i : ℂ))) :
+    ∑ i, (z i)^2 ≤ traceNorm (A*A-B*B) := by
+  let ε : n → ℝ := fun i => if z i<0 then -1 else 1
+  have hε (i : n) : ε i * z i=|z i| := by
+    dsimp [ε]
+    split_ifs with hi
+    · rw [abs_of_neg hi]; ring
+    · rw [abs_of_nonneg (le_of_not_gt hi)]; ring
+  have hεsq (i : n) : ε i*ε i=1 := by dsimp [ε]; split_ifs <;> norm_num
+  let S : Mat n := Matrix.diagonal (fun i => (ε i : ℂ))
+  have hS : Sᴴ*S=1 := by
+    simp only [S,Matrix.diagonal_conjTranspose,
+      Matrix.diagonal_mul_diagonal]
+    ext i j
+    by_cases h : i=j
+    · subst j
+      simp only [Matrix.diagonal_apply_eq,Matrix.one_apply_eq,Pi.star_apply,Complex.star_def,Complex.conj_ofReal,← Complex.ofReal_mul,hεsq,
+        Complex.ofReal_one]
+    · simp [Matrix.diagonal_apply_ne _ h,Matrix.one_apply_ne h]
+  have he : A*A-B*B=(A-B)*A+B*(A-B) := by noncomm_ring
+  have ht : (Matrix.trace (S*(A*A-B*B))).re =
+      ∑ i, |z i| *((A i i).re+(B i i).re) := by
+    rw [he,hz]
+    change (∑ i, (S*((diagonal (fun j => (z j : ℂ)))*A+B*diagonal (fun j => (z j : ℂ)))) i i).re = _
+    rw [Complex.re_sum]
+    apply Finset.sum_congr rfl
+    intro i _
+    simp only [S,Matrix.add_apply,Matrix.diagonal_mul,Matrix.mul_diagonal,
+      Complex.add_re,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,zero_mul,mul_zero,
+      sub_zero]
+    calc
+      ε i * (z i*(A i i).re+(B i i).re*z i)=
+          (ε i*z i)*((A i i).re+(B i i).re) := by ring
+      _ = _ := by rw [hε]
+  have hdiag (i : n) : (A i i).re-(B i i).re=z i := by
+    have h := congrArg (fun M : Mat n => (M i i).re) hz
+    simpa only [Matrix.sub_apply,Complex.sub_re,Matrix.diagonal_apply_eq,Complex.ofReal_re] using h
+  have hi (i : n) : (z i)^2 ≤ |z i| *((A i i).re+(B i i).re) := by
+    have habs : |z i| ≤ (A i i).re+(B i i).re := abs_le.mpr ⟨by
+      linarith [hdiag i,psd_diagonal_real hA i,psd_diagonal_real hB i],by
+      linarith [hdiag i,psd_diagonal_real hA i,psd_diagonal_real hB i]⟩
+    have h := mul_le_mul_of_nonneg_left habs (abs_nonneg (z i))
+    nlinarith [sq_abs (z i)]
+  calc
+    ∑ i, (z i)^2 ≤ ∑ i, |z i| *((A i i).re+(B i i).re) :=
+      Finset.sum_le_sum (fun i _ => hi i)
+    _ = (Matrix.trace (S*(A*A-B*B))).re := ht.symm
+    _ ≤ ‖Matrix.trace (S*(A*A-B*B))‖ := Complex.re_le_norm _
+    _ ≤ traceNorm (A*A-B*B) := trace_unitary_norm_le _ hS
+
+lemma powers_stormer {A B : Mat n} (hA : A.PosSemidef) (hB : B.PosSemidef) :
+    (Matrix.trace ((A-B)*(A-B))).re ≤ traceNorm (A*A-B*B) := by
+  let Z := A-B
+  have hZ : Z.IsHermitian := hA.isHermitian.sub hB.isHermitian
+  obtain ⟨U,hU,hdiag⟩ := unitary_spectral hZ
+  let a := Uᴴ*A*U
+  let b := Uᴴ*B*U
+  have ha : a.PosSemidef := hA.conjTranspose_mul_mul_same U
+  have hb : b.PosSemidef := hB.conjTranspose_mul_mul_same U
+  have hab : a-b=diagonal (fun i => (hZ.eigenvalues i : ℂ)) := by
+    rw [← hdiag]
+    simp only [a,b,Z,Matrix.mul_sub,Matrix.sub_mul]
+  have h := powers_stormer_diagonal ha hb hZ.eigenvalues hab
+  have he : a*a-b*b=Uᴴ*(A*A-B*B)*U := by
+    dsimp only [a,b]
+    rw [unitary_conj_mul hU,unitary_conj_mul hU,Matrix.mul_sub,Matrix.sub_mul]
+  rw [he,unitary_traceNorm_conj hU] at h
+  have ht : (Matrix.trace ((A-B)*(A-B))).re=∑ i, (hZ.eigenvalues i)^2 := by
+    rw [← unitary_trace_conj hU ((A-B)*(A-B)),← unitary_conj_mul hU]
+    change (Matrix.trace ((Uᴴ*Z*U)*(Uᴴ*Z*U))).re=_
+    rw [hdiag,Matrix.diagonal_mul_diagonal,Matrix.trace_diagonal,Complex.re_sum]
+    simp only [Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,mul_zero,sub_zero,pow_two]
+  rwa [ht]
+
+lemma fidelity_lower {H J : Mat n} (hH : H.PosSemidef) (hJ : J.PosSemidef) :
+    ((Matrix.trace H).re+(Matrix.trace J).re-traceNorm (H-J))/2 ≤ fidelity H J := by
+  have h := powers_stormer (sqrt_psd H) (sqrt_psd J)
+  rw [CFC.sqrt_mul_sqrt_self H hH.nonneg,CFC.sqrt_mul_sqrt_self J hJ.nonneg] at h
+  have he : (Matrix.trace ((CFC.sqrt H-CFC.sqrt J)*(CFC.sqrt H-CFC.sqrt J))).re =
+      (Matrix.trace H).re+(Matrix.trace J).re-2*(Matrix.trace (CFC.sqrt H*CFC.sqrt J)).re := by
+    simp only [Matrix.mul_sub,Matrix.sub_mul,Matrix.trace_sub,Complex.sub_re,
+      CFC.sqrt_mul_sqrt_self H hH.nonneg,CFC.sqrt_mul_sqrt_self J hJ.nonneg]
+    rw [Matrix.trace_mul_comm (CFC.sqrt J)]
+    ring
+  rw [he] at h
+  have hf := trace_re_le_traceNorm (CFC.sqrt H*CFC.sqrt J)
+  dsimp [fidelity]
+  linarith
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProbeDensity.lean

@@ -0,0 +1,51 @@
+import OAI.InformationTheory.Entanglement.ConditionalUpdate
+import OAI.InformationTheory.Entanglement.MatrixFamilyDensity
+import OAI.InformationTheory.Entanglement.ProbePOVM
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped BigOperators MeasureTheory ProbabilityTheory
+namespace SecretKey
+variable {Ω T : Type*} {mΩ : MeasurableSpace Ω} [MeasurableSpace T]
+variable {ν : Measure Ω} [IsFiniteMeasure ν] {t : Ω → T} (ht : Measurable t)
+include ht in
+
+lemma transcript_density_condExp {a : Set Ω} (ha : MeasurableSet a)
+    {f : T → ℝ} (hfm : Measurable f) (hfi : Integrable f ((@Measure.map Ω T mΩ _ t ν)))
+    (hf : ∀ s, MeasurableSet s → (∫ u in s, f u ∂(@Measure.map Ω T mΩ _ t ν))=ν.real (a∩t⁻¹' s)) :
+    (fun x => f (t x)) =ᵐ[ν] (ν⟦a | MeasurableSpace.comap t inferInstance⟧) := by
+  have hsub : MeasurableSpace.comap t inferInstance ≤ mΩ := ht.comap_le
+  have hcomp : Integrable (fun x => f (t x)) ν := (integrable_map_measure hfm.aestronglyMeasurable ht.aemeasurable).mp hfi
+  apply ae_eq_condExp_of_forall_setIntegral_eq hsub ((integrable_const (1 : ℝ)).indicator ha)
+  · intro s hs _
+    exact hcomp.integrableOn
+  · intro s hs _
+    obtain ⟨u,hu,rfl⟩ := hs
+    rw [← setIntegral_map hu hfm.aestronglyMeasurable ht.aemeasurable,hf u hu]
+    simp [integral_indicator ha, measureReal_def, Measure.restrict_apply ha,Set.inter_comm]
+  · exact (hfm.comp (comap_measurable t)).stronglyMeasurable.aestronglyMeasurable
+
+lemma independent_transcript_densities [StandardBorelSpace Ω]
+    {A B : MeasurableSpace Ω} (hA : A ≤ mΩ) (hB : B ≤ mΩ)
+    (hind : CondIndep (MeasurableSpace.comap t inferInstance) A B ht.comap_le ν)
+    {a b : Set Ω} (ha : MeasurableSet[A] a) (hb : MeasurableSet[B] b)
+    {f g h : T → ℝ} (hfm : Measurable f) (hgm : Measurable g) (hhm : Measurable h)
+    (hfi : Integrable f ((@Measure.map Ω T mΩ _ t ν))) (hgi : Integrable g ((@Measure.map Ω T mΩ _ t ν)))
+    (hhi : Integrable h ((@Measure.map Ω T mΩ _ t ν)))
+    (hf : ∀ s, MeasurableSet s → (∫ u in s, f u ∂(@Measure.map Ω T mΩ _ t ν))=ν.real (a∩t⁻¹' s))
+    (hg : ∀ s, MeasurableSet s → (∫ u in s, g u ∂(@Measure.map Ω T mΩ _ t ν))=ν.real (b∩t⁻¹' s))
+    (hh : ∀ s, MeasurableSet s → (∫ u in s, h u ∂(@Measure.map Ω T mΩ _ t ν))=ν.real ((a∩b)∩t⁻¹' s)) :
+    h =ᵐ[(@Measure.map Ω T mΩ _ t ν)] f*g := by
+  have he := (condIndep_iff _ _ _ ht.comap_le hA hB ν).mp hind a b ha hb
+  have hf' := transcript_density_condExp ht (hA a ha) hfm hfi hf
+  have hg' := transcript_density_condExp ht (hB b hb) hgm hgi hg
+  have hh' := transcript_density_condExp ht ((hA a ha).inter (hB b hb)) hhm hhi hh
+  apply (ae_map_iff ht.aemeasurable (measurableSet_eq_fun hhm (hfm.mul hgm))).mpr
+  exact hh'.trans (he.trans (hf'.mul hg').symm)
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProbeFactorization.lean

@@ -0,0 +1,82 @@
+import OAI.InformationTheory.Entanglement.ProbeDensity
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix MeasureTheory ProbabilityTheory Filter Set
+namespace SecretKey
+open ChannelCompletion
+variable {n m : Type} [Fintype n] [Fintype m] [DecidableEq n] [DecidableEq m]
+lemma trace_mul_psd_eq_real {E W : Mat n} (hE : E.PosSemidef) (hW : W.PosSemidef) :
+    Matrix.trace (E*W)=((Matrix.trace (E*W)).re : ℂ) := by
+  apply Complex.ext
+  · rfl
+  rw [Complex.ofReal_im]
+  rw [← trace_filter hE]
+  exact (Complex.nonneg_iff.mp (hW.mul_mul_conjTranspose_same _).trace_nonneg).2.symm
+variable {T : Type*} [MeasurableSpace T] {μ : Measure T}
+omit [DecidableEq n] in
+lemma integrable_test_trace (E : Mat n) {W : T → Mat n}
+    (hW : ∀ a b, Integrable (fun t => W t a b) μ) :
+    Integrable (fun t => (Matrix.trace (E*W t)).re) μ := by
+  have h : Integrable (fun t => Matrix.trace (E*W t)) μ := by
+    simp only [Matrix.trace,Matrix.diag,Matrix.mul_apply]
+    exact integrable_finsetSum _ fun a _ => integrable_finsetSum _ fun b _ => (hW b a).const_mul _
+  exact h.re
+omit [DecidableEq n] in
+lemma measurable_test_trace (E : Mat n) {W : T → Mat n} (hW : Measurable W) :
+    Measurable (fun t => (Matrix.trace (E*W t)).re) := by
+  have hc : Continuous (fun M : Mat n => (Matrix.trace (E*M)).re) := by fun_prop
+  exact hc.measurable.comp hW
+variable {Ω : Type*} {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω]
+variable {ν : Measure Ω} [IsFiniteMeasure ν] {t : Ω → T}
+
+theorem probe_density_product (ht : Measurable t)
+    {A B : MeasurableSpace Ω} (hA : A ≤ mΩ) (hB : B ≤ mΩ)
+    (hind : CondIndep (MeasurableSpace.comap t inferInstance) A B ht.comap_le ν)
+    (a : Fin 2 → Option (PositiveTestIndex n) → Set Ω)
+    (b : Fin 2 → Option (PositiveTestIndex m) → Set Ω)
+    (ha : ∀ i e, MeasurableSet[A] (a i e)) (hb : ∀ j g, MeasurableSet[B] (b j g))
+    (U : Fin 2 → T → Mat n) (V : Fin 2 → T → Mat m)
+    (W : Fin 2 → Fin 2 → T → Mat (n×m))
+    (hUp : ∀ i u, (U i u).PosSemidef) (hVp : ∀ j u, (V j u).PosSemidef)
+    (hWp : ∀ i j u, (W i j u).PosSemidef)
+    (hUm : ∀ i, Measurable (U i)) (hVm : ∀ j, Measurable (V j))
+    (hWm : ∀ i j, Measurable (W i j))
+    (hUi : ∀ i a b, Integrable (fun u => U i u a b) (@Measure.map Ω T mΩ _ t ν))
+    (hVi : ∀ j a b, Integrable (fun u => V j u a b) (@Measure.map Ω T mΩ _ t ν))
+    (hWi : ∀ i j a b, Integrable (fun u => W i j u a b) (@Measure.map Ω T mΩ _ t ν))
+    (hUlaw : ∀ i e s, MeasurableSet s →
+      (∫ u in s, (Matrix.trace (probePOVM e*U i u)).re ∂(@Measure.map Ω T mΩ _ t ν))=
+        ν.real (a i e∩t⁻¹' s))
+    (hVlaw : ∀ j g s, MeasurableSet s →
+      (∫ u in s, (Matrix.trace (probePOVM g*V j u)).re ∂(@Measure.map Ω T mΩ _ t ν))=
+        ν.real (b j g∩t⁻¹' s))
+    (hWlaw : ∀ i j e g s, MeasurableSet s →
+      (∫ u in s, (Matrix.trace ((probePOVM e ⊗ₖ probePOVM g)*W i j u)).re
+        ∂(@Measure.map Ω T mΩ _ t ν))=ν.real ((a i e∩b j g)∩t⁻¹' s)) :
+    ∀ᵐ u ∂(@Measure.map Ω T mΩ _ t ν), ∀ i j, W i j u=U i u ⊗ₖ V j u := by
+  have he (i j : Fin 2) (e : Option (PositiveTestIndex n)) (g : Option (PositiveTestIndex m)) :
+      (fun u => (Matrix.trace ((probePOVM e ⊗ₖ probePOVM g)*W i j u)).re)=ᵐ[(@Measure.map Ω T mΩ _ t ν)]
+        (fun u => (Matrix.trace (probePOVM e*U i u)).re*(Matrix.trace (probePOVM g*V j u)).re) := by
+    exact independent_transcript_densities ht hA hB hind (ha i e) (hb j g)
+      (measurable_test_trace _ (hUm i)) (measurable_test_trace _ (hVm j))
+      (measurable_test_trace _ (hWm i j))
+      (integrable_test_trace _ (hUi i)) (integrable_test_trace _ (hVi j))
+      (integrable_test_trace _ (hWi i j)) (hUlaw i e) (hVlaw j g) (hWlaw i j e g)
+  have hall := ae_all_iff.mpr (fun i => ae_all_iff.mpr (fun j =>
+    ae_all_iff.mpr (fun e => ae_all_iff.mpr (he i j e))))
+  filter_upwards [hall] with u hu
+  intro i j
+  apply tensor_product_of_probePOVM
+  intro e g
+  rw [trace_mul_psd_eq_real ((probePOVM_psd e).kronecker (probePOVM_psd g)) (hWp i j u),
+    trace_mul_psd_eq_real (probePOVM_psd e) (hUp i u),
+    trace_mul_psd_eq_real (probePOVM_psd g) (hVp j u),← Complex.ofReal_mul,hu i j e g]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProbeMatrices.lean

@@ -0,0 +1,52 @@
+import OAI.InformationTheory.Entanglement.ProbeDensity
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix MeasureTheory Filter
+namespace SecretKey
+open ChannelCompletion
+variable {n m : Type} [Fintype n] [Fintype m] [DecidableEq n] [DecidableEq m]
+def marginalLeft (W : Mat (n×m)) : Mat n := fun i j => ∑ a, W (i,a) (j,a)
+def marginalRight (W : Mat (n×m)) : Mat m := fun a b => ∑ i, W (i,a) (i,b)
+omit [DecidableEq n] [DecidableEq m] in
+lemma marginalLeft_psd {W : Mat (n×m)} (hW : W.PosSemidef) : (marginalLeft W).PosSemidef :=
+  partial_trace_psd hW
+omit [Fintype m] [DecidableEq n] [DecidableEq m] in
+lemma marginalRight_psd {W : Mat (n×m)} (hW : W.PosSemidef) : (marginalRight W).PosSemidef := by
+  have he : marginalRight W=∑ i, W.submatrix (fun a => (i,a)) (fun a => (i,a)) := by ext a b; simp [marginalRight,Matrix.sum_apply,Matrix.submatrix_apply]
+  rw [he]
+  exact Matrix.posSemidef_sum _ (fun i _ => hW.submatrix _)
+omit [DecidableEq n] in
+lemma trace_test_left (E : Mat n) (W : Mat (n×m)) :
+    Matrix.trace (E*marginalLeft W)=Matrix.trace ((E ⊗ₖ (1 : Mat m))*W) := by
+  simp only [Matrix.trace,Matrix.diag,Matrix.mul_apply,marginalLeft,Matrix.kronecker_apply,
+    Fintype.sum_prod_type,Matrix.one_apply,mul_ite,mul_one,mul_zero,ite_mul,zero_mul,Finset.sum_ite_eq,
+    Finset.mem_univ,ite_true,Finset.mul_sum]
+  exact Finset.sum_congr rfl (fun i _ => Finset.sum_comm)
+omit [DecidableEq m] in
+lemma trace_test_right (G : Mat m) (W : Mat (n×m)) :
+    Matrix.trace (G*marginalRight W)=Matrix.trace (((1 : Mat n) ⊗ₖ G)*W) := by
+  have hh (i : n) (a : m) :
+      (∑ k : n, ∑ b : m, if i=k then G a b*W (k,b) (i,a) else 0)=
+        ∑ b : m, G a b*W (i,b) (i,a) := by
+    rw [Finset.sum_eq_single i]
+    · simp
+    · intro k _ hk
+      simp [Ne.symm hk]
+    · simp
+  simp only [Matrix.trace,Matrix.diag,Matrix.mul_apply,marginalRight,Matrix.kronecker_apply,
+    Fintype.sum_prod_type,Matrix.one_apply,ite_mul,one_mul,zero_mul,Finset.mul_sum]
+  change (∑ a : m, ∑ b : m, ∑ i : n, G a b*W (i,b) (i,a))=
+    ∑ i : n, ∑ a : m, ∑ k : n, ∑ b : m, if i=k then G a b*W (k,b) (i,a) else 0
+  simp_rw [hh]
+  calc
+    _=∑ a : m, ∑ i : n, ∑ b : m, G a b*W (i,b) (i,a) :=
+      Finset.sum_congr rfl (fun a _ => Finset.sum_comm)
+    _=_ := Finset.sum_comm
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProbePOVM.lean

@@ -0,0 +1,84 @@
+import OAI.InformationTheory.Entanglement.InformationalComplete
+import OAI.Analysis.Quantum.PPTSquare.ChannelModel
+import OAI.Analysis.Quantum.PPTSquare.TraceCompletion
+import OAI.Analysis.Quantum.PPTSquare.Compression
+import OAI.Analysis.Quantum.PPTSquare.ChannelCompletion
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace SecretKey
+open ChannelCompletion
+variable {n m : Type} [Fintype n] [Fintype m] [DecidableEq n] [DecidableEq m]
+def testSum (n : Type) [Fintype n] [DecidableEq n] : Mat n :=
+  ∑ k : PositiveTestIndex n, positiveTest k
+lemma testSum_psd : (testSum n).PosSemidef := by
+  exact Matrix.posSemidef_sum _ (fun k _ => positiveTest_psd k)
+def probeScale (n : Type) [Fintype n] [DecidableEq n] : ℝ :=
+  (1+(Matrix.trace (testSum n)).re)⁻¹
+lemma probeScale_pos : 0<probeScale n := by
+  apply inv_pos.mpr
+  have h := (Complex.nonneg_iff.mp (testSum_psd (n := n)).trace_nonneg).1
+  linarith
+lemma probeScale_mul_trace : probeScale n+(probeScale n)*(Matrix.trace (testSum n)).re=1 := by
+  unfold probeScale
+  have h := (Complex.nonneg_iff.mp (testSum_psd (n := n)).trace_nonneg).1
+  field_simp
+
+def probePOVM : Option (PositiveTestIndex n) → Mat n
+  | some k => (probeScale n : ℂ) • positiveTest k
+  | none => 1-(probeScale n : ℂ) • testSum n
+lemma probePOVM_psd (k : Option (PositiveTestIndex n)) : (probePOVM k).PosSemidef := by
+  cases k with
+  | some k => exact (positiveTest_psd k).smul (by exact_mod_cast (probeScale_pos (n := n)).le)
+  | none =>
+    have htrace : ((Matrix.trace (testSum n)).re : ℂ)=Matrix.trace (testSum n) := by
+      exact Complex.ext rfl (by simpa using (Complex.nonneg_iff.mp (testSum_psd (n := n)).trace_nonneg).2)
+    have he : (1-(probeScale n : ℂ) • testSum n) =
+        (probeScale n : ℂ) • (1 : Mat n)+
+          (probeScale n : ℂ) • (Matrix.trace (testSum n) • (1 : Mat n)-testSum n) := by
+      rw [smul_sub,smul_smul,← add_sub_assoc,← add_smul]
+      have hc : (probeScale n : ℂ)+(probeScale n : ℂ)*Matrix.trace (testSum n)=1 := by
+        rw [← htrace,← Complex.ofReal_mul,← Complex.ofReal_add,probeScale_mul_trace]
+        rfl
+      rw [hc,one_smul]
+    change (1-(probeScale n : ℂ) • testSum n).PosSemidef
+    rw [he]
+    exact (Matrix.PosSemidef.one.smul (by exact_mod_cast (probeScale_pos (n := n)).le)).add
+      ((psd_trace_bound testSum_psd).smul (by exact_mod_cast (probeScale_pos (n := n)).le))
+lemma probePOVM_sum : (∑ k : Option (PositiveTestIndex n), probePOVM k) = 1 := by
+  rw [Fintype.sum_option]
+  simp only [probePOVM,← Finset.smul_sum,testSum]
+  abel
+lemma linear_eq_zero_of_probePOVM (L : Mat n →ₗ[ℂ] ℂ)
+    (h : ∀ k, L (probePOVM k)=0) : L=0 := by
+  apply linear_eq_zero_of_positive_tests L
+  intro k
+  have hk := h (some k)
+  change L ((probeScale n : ℂ) • positiveTest k)=0 at hk
+  rw [map_smul,smul_eq_mul] at hk
+  exact (mul_eq_zero.mp hk).resolve_left (by exact_mod_cast (probeScale_pos (n := n)).ne')
+
+theorem tensor_product_of_probePOVM (W : Mat (n×m)) (X : Mat n) (Y : Mat m)
+    (htest : ∀ e : Option (PositiveTestIndex n), ∀ g : Option (PositiveTestIndex m),
+      Matrix.trace ((probePOVM e ⊗ₖ probePOVM g)*W)=
+        Matrix.trace (probePOVM e*X)*Matrix.trace (probePOVM g*Y)) :
+    W=X ⊗ₖ Y := by
+  apply tensor_product_of_positive_tests
+  intro e g
+  have h := htest (some e) (some g)
+  simp only [probePOVM,Matrix.smul_kronecker,Matrix.kronecker_smul,Matrix.smul_mul,
+    Matrix.trace_smul,smul_eq_mul] at h
+  have hc : (probeScale n : ℂ) ≠ 0 := by exact_mod_cast (probeScale_pos (n := n)).ne'
+  have hd : (probeScale m : ℂ) ≠ 0 := by exact_mod_cast (probeScale_pos (n := m)).ne'
+  apply mul_left_cancel₀ hc
+  apply mul_left_cancel₀ hd
+  linear_combination h
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProbeRescaling.lean

@@ -0,0 +1,66 @@
+import OAI.InformationTheory.Entanglement.NormalizedProbe
+import OAI.InformationTheory.Entanglement.ConditionedLaw
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped MeasureTheory ProbabilityTheory ENNReal NNReal
+namespace SecretKey
+variable {Ω : Type*} {mΩ : MeasurableSpace Ω}
+
+lemma condExp_rescale {μ : Measure Ω} [IsFiniteMeasure μ]
+    {F : MeasurableSpace Ω} (hF : F ≤ mΩ) {f : Ω→ℝ} (hf : Integrable f μ)
+    (c : ℝ≥0) : μ[f|F]=ᵐ[c•μ] (c•μ)[f|F] := by
+  apply ae_eq_condExp_of_forall_setIntegral_eq hF hf.smul_measure_nnreal
+  · intro s hs hfin
+    exact (integrable_condExp.smul_measure_nnreal (c := c)).integrableOn
+  · intro s hs hfin
+    rw [Measure.restrict_smul,integral_smul_nnreal_measure,integral_smul_nnreal_measure,
+      setIntegral_condExp hF hf hs]
+  · exact stronglyMeasurable_condExp.aestronglyMeasurable
+lemma condIndep_rescale {μ : Measure Ω} [IsFiniteMeasure μ]
+    [StandardBorelSpace Ω] {F A B : MeasurableSpace Ω}
+    (hF : F ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ)
+    (hind : CondIndep F A B hF μ) (c : ℝ≥0) : CondIndep F A B hF (c•μ) := by
+  rw [condIndep_iff _ _ _ hF hA hB] at hind ⊢
+  intro s t hs ht
+  have hi (u : Set Ω) (hu : MeasurableSet[mΩ] u) : Integrable (u.indicator (fun _ => (1 : ℝ))) μ :=
+    (integrable_const 1).indicator hu
+  have hst := condExp_rescale hF (hi (s∩t) ((hA s hs).inter (hB t ht))) c
+  have hsa := condExp_rescale hF (hi s (hA s hs)) c
+  have htb := condExp_rescale hF (hi t (hB t ht)) c
+  filter_upwards [hst,hsa,htb,Measure.ae_smul_measure (hind s t hs ht) c] with x hx hy hz hc
+  simp only [Pi.mul_apply] at hc ⊢
+  rw [← hx,← hy,← hz]
+  exact hc
+namespace PositiveMatrixMeasure
+open ChannelCompletion Matrix
+variable {n : Type} [Fintype n]
+
+lemma scale_traceMeasure (W : PositiveMatrixMeasure Ω n) (c : ℝ≥0) :
+    (W.scale (c : ℝ) (NNReal.coe_nonneg c)).traceMeasure=c • W.traceMeasure := by
+  apply Measure.ext
+  intro s hs
+  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
+  change (W.scale (c : ℝ) (NNReal.coe_nonneg c)).traceMeasure.real s=(c • W.traceMeasure).real s
+  rw [traceMeasure_real _ hs,scale_value,Matrix.trace_smul,
+    measureReal_nnreal_smul_apply,traceMeasure_real _ hs]
+  simp [smul_eq_mul]
+lemma scale_domination (W : PositiveMatrixMeasure Ω n) {μ : Measure Ω}
+    (h : W.traceMeasure ≪ μ) (c : ℝ≥0) :
+    (W.scale (c : ℝ) (NNReal.coe_nonneg c)).traceMeasure ≪ c • μ := by
+  rw [scale_traceMeasure]
+  exact h.smul c
+lemma scale_born (W : PositiveMatrixMeasure Ω n) (E : Mat n) (s : Set Ω) (c : ℝ≥0) :
+    (Matrix.trace (E*(W.scale (c : ℝ) (NNReal.coe_nonneg c)).value s)).re=
+      c*(Matrix.trace (E*W.value s)).re := by
+  rw [scale_value,Matrix.mul_smul,Matrix.trace_smul]
+  simp [smul_eq_mul]
+end PositiveMatrixMeasure
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProductInstrumentStep.lean

@@ -0,0 +1,61 @@
+import OAI.InformationTheory.Entanglement.TraceInstrument
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators InnerProductSpace ComplexOrder ENNReal MeasureTheory TensorProduct
+open ContinuousLinearMap MeasureTheory ProbabilityTheory
+namespace SecretKey
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ : Type*} {X : Type*} [MeasurableSpace X]
+
+def traceClassCoefficient (b : HilbertBasis ι ℂ H) (x y : H) : TraceClass b →ₗ[ℂ] ℂ where
+  toFun A := inner ℂ x ((A : H →L[ℂ] H) y)
+  map_add' A B := by simp
+  map_smul' c A := by simp
+
+omit [CompleteSpace H] [CompleteSpace L] in
+theorem local_product_disintegration (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d)
+    (U : I.ConditionalUpdate ρ) {s : Set X} (hs : MeasurableSet s)
+    (x y : K) (u v : L) :
+    tensorFunctional (traceClassCoefficient c x y) (traceClassCoefficient d u v)
+      (TensorProduct.map (I.event s) LinearMap.id (ρ.val ⊗ₜ[ℂ] σ.val))=
+    ∫ z in s, tensorFunctional (traceClassCoefficient c x y) (traceClassCoefficient d u v)
+      ((U.state z).val ⊗ₜ[ℂ] σ.val) ∂I.outcome ρ := by
+  simp only [local_product_event,tensorFunctional_tmul,traceClassCoefficient,LinearMap.coe_mk,
+    AddHom.coe_mk]
+  rw [U.disintegration s hs x y,integral_mul_const]
+
+omit [CompleteSpace H] [CompleteSpace L] in
+theorem right_product_disintegration (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d)
+    (U : I.ConditionalUpdate ρ) {s : Set X} (hs : MeasurableSet s)
+    (x y : K) (u v : L) :
+    tensorFunctional (traceClassCoefficient d u v) (traceClassCoefficient c x y)
+      (TensorProduct.map LinearMap.id (I.event s) (σ.val ⊗ₜ[ℂ] ρ.val))=
+    ∫ z in s, tensorFunctional (traceClassCoefficient d u v) (traceClassCoefficient c x y)
+      (σ.val ⊗ₜ[ℂ] (U.state z).val) ∂I.outcome ρ := by
+  simp only [TensorProduct.map_tmul,tensorFunctional_tmul,LinearMap.id_apply,
+    traceClassCoefficient,LinearMap.coe_mk,AddHom.coe_mk]
+  rw [U.disintegration s hs x y,integral_const_mul]
+
+omit [CompleteSpace H] [CompleteSpace L] in
+lemma conditional_product_trace (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d)
+    (U : I.ConditionalUpdate ρ) (z : X) :
+    tensorFunctional (traceClassTrace c) (traceClassTrace d)
+      ((U.state z).val ⊗ₜ[ℂ] σ.val)=1 := by
+  rw [tensorFunctional_tmul,(U.state z).property.2,σ.property.2,mul_one]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionData.lean

@@ -0,0 +1,118 @@
+import OAI.InformationTheory.Entanglement.TensorTools
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion
+variable {Q K D I : Type} [Fintype Q] [Fintype K] [Fintype D] [Fintype I]
+  [DecidableEq Q] [DecidableEq D] [DecidableEq I]
+
+def correlation (u : Q → K → ℝ) (q r : Q) : ℝ := ∑ a, u q a * u r a
+
+structure Data (Q K D I : Type) [Fintype Q] [Fintype K] [Fintype D] [Fintype I]
+    [DecidableEq Q] [DecidableEq D] where
+  question : I → Q
+  u : Q → K → ℝ
+  unit : ∀ q, ∑ a, u q a * u q a = 1
+  P : I → Mat D
+  hermitian : ∀ i, (P i).IsHermitian
+  idempotent : ∀ i, P i * P i = P i
+  orthogonal : ∀ i j, question i = question j → i ≠ j → P i * P j = 0
+  complete : ∀ q, ∑ i with question i = q, P i = 1
+  commute : ∀ i j, correlation u (question i) (question j) ≠ 0 → P i * P j = P j * P i
+  κ : ℝ
+  gap : κ < (Fintype.card Q : ℝ) / Fintype.card K
+  clique : ∀ J : Finset I,
+    (∀ i ∈ J, ∀ j ∈ J, i ≠ j → 0 < (Matrix.trace (P i * P j)).re) →
+    (J.card : ℝ) ≤ κ
+
+namespace Data
+variable (d : Data Q K D I)
+def c (i j : I) : ℝ := correlation d.u (d.question i) (d.question j)
+def H (i j : I) : Mat D := (d.c i j : ℂ) • (d.P i * d.P j)
+def Psi : Map I D where
+  toFun X := ∑ i, ∑ j, X i j • d.H i j
+  map_add' X Y := by simp [add_smul,Finset.sum_add_distrib]
+  map_smul' a X := by simp [smul_smul,Finset.smul_sum]
+def C : Mat (I × I) := choi ((hsAdjoint d.Psi).comp d.Psi)
+def B : Mat I := fun i j => d.C (i,i) (j,j)
+
+omit [DecidableEq I] in
+lemma c_symm (i j : I) : d.c i j = d.c j i := by
+  simp only [c,correlation,mul_comm]
+omit [DecidableEq I] in
+lemma c_self (i : I) : d.c i i = 1 := d.unit (d.question i)
+omit [DecidableEq I] in
+lemma P_psd (i : I) : (d.P i).PosSemidef := by
+  have h := Matrix.posSemidef_conjTranspose_mul_self (d.P i)
+  simpa only [(d.hermitian i).eq,d.idempotent] using h
+omit [DecidableEq I] in
+lemma H_self (i : I) : d.H i i = d.P i := by simp [H,d.c_self,d.idempotent]
+omit [DecidableEq I] in
+lemma H_symm (i j : I) : d.H i j = d.H j i := by
+  by_cases h : d.c i j = 0
+  · simp [H,h,← d.c_symm i j]
+  · rw [H,H,← d.c_symm i j,d.commute i j h]
+omit [DecidableEq I] in
+lemma H_adjoint (i j : I) : (d.H i j)ᴴ = d.H j i := by
+  simp only [H,Matrix.conjTranspose_smul,Matrix.conjTranspose_mul,
+    (d.hermitian i).eq,(d.hermitian j).eq,Complex.star_def,Complex.conj_ofReal,d.c_symm i j]
+omit [DecidableEq I] in
+lemma H_hermitian (i j : I) : (d.H i j).IsHermitian := by
+  rw [Matrix.IsHermitian,d.H_adjoint,d.H_symm]
+lemma Psi_single (i j : I) : d.Psi (Matrix.single i j 1) = d.H i j := by
+  simp [Psi,Matrix.single_apply,ite_and,ite_smul]
+lemma choi_Psi : choi d.Psi = fun a b => d.H a.1 b.1 a.2 b.2 := by
+  ext ⟨i,a⟩ ⟨j,b⟩
+  exact congrArg (fun X : Mat D => X a b) (d.Psi_single i j)
+
+def gramFactor : Matrix (K × D) (I × D) ℂ :=
+  fun a b => (d.u (d.question b.1) a.1 : ℂ) * d.P b.1 a.2 b.2
+lemma choi_gram : choi d.Psi = d.gramFactorᴴ * d.gramFactor := by
+  rw [d.choi_Psi]
+  ext ⟨i,a⟩ ⟨j,b⟩
+  change (d.c i j : ℂ) * (∑ e, d.P i a e * d.P j e b) = _
+  simp only [Matrix.mul_apply,Matrix.conjTranspose_apply,gramFactor,star_mul,
+    Complex.star_def,Complex.conj_ofReal,Fintype.sum_prod_type]
+  have hp (e : D) : star (d.P i e a) = d.P i a e := (d.hermitian i).apply a e
+  simp only [← Complex.star_def,hp]
+  rw [c,correlation,Complex.ofReal_sum]
+  simp only [Complex.ofReal_mul,Finset.sum_mul,Finset.mul_sum]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro k _
+  apply Finset.sum_congr rfl
+  intro e _
+  ring
+lemma Psi_cp : CP d.Psi := by
+  apply cp_of_choi
+  rw [d.choi_gram]
+  exact Matrix.posSemidef_conjTranspose_mul_self _
+omit [DecidableEq I] in
+lemma Psi_input_transpose : d.Psi.comp transposeMap = d.Psi := by
+  ext X a b
+  change (∑ i, ∑ j, X j i • d.H i j) a b = (∑ i, ∑ j, X i j • d.H i j) a b
+  rw [Finset.sum_comm]
+  simp only [Matrix.sum_apply,Matrix.smul_apply]
+  apply Finset.sum_congr rfl
+  intro i _
+  apply Finset.sum_congr rfl
+  intro j _
+  rw [d.H_symm]
+lemma Psi_ppt : PPT d.Psi := by
+  refine ⟨d.Psi_cp,?_⟩
+  have h := cp_simultaneous_transpose d.Psi_cp
+  rwa [d.Psi_input_transpose] at h
+lemma adjoint_ppt : PPT (hsAdjoint d.Psi) := ppt_hsAdjoint d.Psi_ppt
+lemma adjoint_output_transpose : transposeMap.comp (hsAdjoint d.Psi) = hsAdjoint d.Psi := by
+  rw [← hsAdjoint_input_transpose,d.Psi_input_transpose]
+
+end Data
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionMain.lean

@@ -0,0 +1,51 @@
+import OAI.InformationTheory.Entanglement.ProjectionStats
+import OAI.InformationTheory.Entanglement.CorrelationBound
+import OAI.InformationTheory.Entanglement.SparseSeparable
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion
+variable {Q K D I : Type} [Fintype Q] [Fintype K] [Fintype D] [Fintype I]
+  [DecidableEq Q] [DecidableEq K] [DecidableEq D] [DecidableEq I]
+  [Nonempty Q] [Nonempty K] [Nonempty D]
+
+namespace Data
+variable (d : Data Q K D I)
+lemma C_nonseparable : ¬ Separable d.C := by
+  intro hsep
+  have hu := separable_compression_bound hsep d.κ (fun J hJ => d.clique J (by
+    simpa only [d.C_diag] using hJ))
+  have ht : compressionTrace d.C=(Fintype.card Q : ℝ)*(Fintype.card D : ℝ) := by
+    change (Matrix.trace d.B).re = _
+    rw [d.B_trace]
+    simp
+  have hs : compressionSum d.C=(∑ q, ∑ r, (correlation d.u q r)^2)*(Fintype.card D : ℝ) := by
+    change (∑ i, ∑ j, d.B i j).re = _
+    rw [d.B_sum]
+    simp [-Complex.ofReal_pow]
+  rw [ht,hs] at hu
+  have hD : 0 < (Fintype.card D : ℝ) := Nat.cast_pos.mpr Fintype.card_pos
+  have hQ : 0 < (Fintype.card Q : ℝ) := Nat.cast_pos.mpr Fintype.card_pos
+  have hlo := mul_le_mul_of_nonneg_right (correlation_lower d.u d.unit) hD.le
+  have hhi := mul_lt_mul_of_pos_right d.gap (mul_pos hQ hD)
+  have he : (Fintype.card Q : ℝ)/Fintype.card K*
+      ((Fintype.card Q : ℝ)*Fintype.card D) =
+      (Fintype.card Q : ℝ)^2/Fintype.card K*Fintype.card D := by ring
+  rw [he] at hhi
+  exact (not_lt_of_ge (hlo.trans hu)) hhi
+end Data
+
+theorem rectangular_projection_criterion (d : Data Q K D I) :
+    PPT d.Psi ∧ PPT (hsAdjoint d.Psi) ∧ ¬ Separable d.C ∧
+      Matrix.trace d.C=(Fintype.card Q : ℂ)^2*(Fintype.card D : ℂ) := by
+  exact ⟨d.Psi_ppt,d.adjoint_ppt,d.C_nonseparable,d.C_trace⟩
+
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionReal.lean

@@ -0,0 +1,104 @@
+import OAI.InformationTheory.Entanglement.ProjectionMain
+import OAI.InformationTheory.Entanglement.ChoiTransfer
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion SecretKey
+namespace Data
+variable {Q K D I : Type} [Fintype Q] [Fintype K] [Fintype D] [Fintype I]
+  [DecidableEq Q] [DecidableEq K] [DecidableEq D] [DecidableEq I]
+variable (d : Data Q K D I)
+
+def RealProjections : Prop := ∀ i a b, (d.P i a b).im=0
+omit [DecidableEq K] [DecidableEq I] in
+lemma P_transpose (hr : d.RealProjections) (i : I) : (d.P i)ᵀ=d.P i := by
+  ext a b
+  have he := (d.hermitian i).apply a b
+  rw [Complex.ext_iff] at he ⊢
+  exact ⟨he.1,by change (d.P i b a).im=(d.P i a b).im; rw [hr i b a,hr i a b]⟩
+omit [DecidableEq K] [DecidableEq I] in
+lemma H_transpose (hr : d.RealProjections) (i j : I) : (d.H i j)ᵀ=d.H i j := by
+  simp only [H,Matrix.transpose_smul,Matrix.transpose_mul,d.P_transpose hr]
+  by_cases hc : d.c i j=0
+  · simp [hc]
+  · rw [d.commute i j hc]
+omit [DecidableEq K] in
+lemma adjoint_input_transpose (hr : d.RealProjections) :
+    (hsAdjoint d.Psi).comp transposeMap=hsAdjoint d.Psi := by
+  ext A i j
+  change hsAdjoint d.Psi Aᵀ i j=hsAdjoint d.Psi A i j
+  simp only [d.adjoint_apply,(d.H_hermitian i j).eq]
+  rw [← d.H_transpose hr i j,Matrix.trace_transpose_mul,d.H_transpose hr i j]
+omit [DecidableEq K] in
+lemma adjoint_trace (A : Mat D) :
+    Matrix.trace (hsAdjoint d.Psi A)=(Fintype.card Q : ℂ)*Matrix.trace A := by
+  change (∑ i, hsAdjoint d.Psi A i i)=_
+  simp_rw [d.adjoint_apply,d.H_self,(d.hermitian _).eq,Matrix.trace_mul_comm (d.P _) A]
+  simpa only [one_mul,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one]
+    using d.weighted_trace (fun _ => 1) A
+omit [DecidableEq K] in
+lemma choi_real (hr : d.RealProjections) :
+    d.C=tensorMap (hsAdjoint d.Psi) (hsAdjoint d.Psi) (projector (omega (n := D))) := by
+  change choi ((hsAdjoint d.Psi).comp d.Psi)=_
+  rw [choi_transfer d.Psi_cp]
+  have he : sharp d.Psi=hsAdjoint d.Psi := by
+    rw [sharp,d.adjoint_input_transpose hr,d.adjoint_output_transpose]
+  rw [he]
+
+def localChannel : Map D I := (((Fintype.card Q : ℝ)⁻¹ : ℝ) : ℂ) • hsAdjoint d.Psi
+def rho : Mat (I × I) := ((((Fintype.card Q : ℝ)^2*(Fintype.card D : ℝ))⁻¹ : ℝ) : ℂ) • d.C
+
+omit [DecidableEq K] in
+lemma localChannel_ppt : PPT d.localChannel := by
+  refine ⟨cp_smul d.adjoint_ppt.1 (inv_nonneg.mpr (Nat.cast_nonneg _)),?_⟩
+  change CP ((((Fintype.card Q : ℝ)⁻¹ : ℝ) : ℂ) • (transposeMap.comp (hsAdjoint d.Psi)))
+  exact cp_smul d.adjoint_ppt.2 (inv_nonneg.mpr (Nat.cast_nonneg _))
+omit [DecidableEq K] in
+lemma localChannel_tp [Nonempty Q] : TracePreserving d.localChannel := by
+  intro A
+  change Matrix.trace ((((Fintype.card Q : ℝ)⁻¹ : ℝ) : ℂ) • hsAdjoint d.Psi A)=_
+  rw [Matrix.trace_smul,d.adjoint_trace,smul_eq_mul]
+  have hq : (Fintype.card Q : ℂ) ≠ 0 := Nat.cast_ne_zero.mpr (ne_of_gt Fintype.card_pos)
+  push_cast
+  field_simp
+
+omit [DecidableEq K] in
+lemma rho_psd : d.rho.PosSemidef :=
+  (cp_choi (cp_comp d.adjoint_ppt.1 d.Psi_cp)).smul (by
+    change (0 : ℂ) ≤ (((Fintype.card Q : ℝ)^2*(Fintype.card D : ℝ))⁻¹ : ℝ)
+    have hn : 0 ≤ ((Fintype.card Q : ℝ)^2*(Fintype.card D : ℝ))⁻¹ := by positivity
+    exact_mod_cast hn)
+omit [DecidableEq K] in
+lemma rho_trace [Nonempty Q] [Nonempty D] : Matrix.trace d.rho=1 := by
+  rw [rho,Matrix.trace_smul,d.C_trace,smul_eq_mul]
+  have hq : (Fintype.card Q : ℂ) ≠ 0 := Nat.cast_ne_zero.mpr (ne_of_gt Fintype.card_pos)
+  have hd : (Fintype.card D : ℂ) ≠ 0 := Nat.cast_ne_zero.mpr (ne_of_gt Fintype.card_pos)
+  push_cast
+  field_simp
+
+omit [Fintype I] [DecidableEq I] in
+lemma separable_scaling {Z : Mat (I × I)} (hZ : Separable Z) {a : ℝ} (ha : 0 ≤ a) :
+    Separable ((a : ℂ) • Z) := by
+  obtain ⟨r,A,B,hA,hB,rfl⟩ := hZ
+  refine ⟨r,fun i => (a : ℂ) • A i,B,fun i => (hA i).smul (by exact_mod_cast ha),hB,?_⟩
+  simp only [Finset.smul_sum,Matrix.smul_kronecker]
+lemma rho_nonseparable [Nonempty Q] [Nonempty K] [Nonempty D] : ¬ Separable d.rho := by
+  intro h
+  have hq : (Fintype.card Q : ℝ)≠0 := Nat.cast_ne_zero.mpr (ne_of_gt Fintype.card_pos)
+  have hd : (Fintype.card D : ℝ)≠0 := Nat.cast_ne_zero.mpr (ne_of_gt Fintype.card_pos)
+  have hz := separable_scaling h (mul_nonneg (sq_nonneg (Fintype.card Q : ℝ)) (Nat.cast_nonneg (Fintype.card D)))
+  have he : ((((Fintype.card Q : ℝ)^2*(Fintype.card D : ℝ)) : ℝ) : ℂ) • d.rho=d.C := by
+    rw [rho,smul_smul,← Complex.ofReal_mul,mul_inv_cancel₀ (mul_ne_zero (pow_ne_zero _ hq) hd)]
+    simp
+  rw [he] at hz
+  exact d.C_nonseparable hz
+end Data
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionRealMain.lean

@@ -0,0 +1,70 @@
+import OAI.InformationTheory.Entanglement.ProjectionReal
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion SecretKey
+
+lemma projector_real_smul {n : Type} (r : ℝ) (v : n → ℂ) :
+    projector ((r : ℂ) • v)=((r^2 : ℝ) : ℂ) • projector v := by
+  ext i j
+  simp only [projector,Matrix.vecMulVec_apply,Pi.smul_apply,Pi.star_apply,smul_eq_mul,
+    star_mul,Complex.star_def,Complex.conj_ofReal,Matrix.smul_apply,Complex.ofReal_pow]
+  ring
+
+def Phi (D : ℕ) : Fin D × Fin D → ℂ := (((Real.sqrt (D : ℝ))⁻¹ : ℝ) : ℂ) • omega
+lemma Phi_projector (D : ℕ) : projector (Phi D)=(((D : ℝ)⁻¹ : ℝ) : ℂ) • projector (omega (n := Fin D)) := by
+  rw [Phi,projector_real_smul,inv_pow,Real.sq_sqrt (Nat.cast_nonneg D)]
+
+namespace Data
+variable {Q K I : Type} [Fintype Q] [Fintype K] [Fintype I]
+  [DecidableEq Q] [DecidableEq K] [DecidableEq I]
+  [Nonempty Q] [Nonempty K] {D : ℕ} [NeZero D]
+variable (d : Data Q K (Fin D) I)
+omit [DecidableEq K] [Nonempty Q] [Nonempty K] [NeZero D] in
+lemma localChannel_input_transpose (hr : d.RealProjections) :
+    d.localChannel.comp transposeMap=d.localChannel := by
+  unfold localChannel
+  rw [LinearMap.smul_comp,d.adjoint_input_transpose hr]
+
+omit [DecidableEq K] [Nonempty Q] [Nonempty K] [NeZero D] in
+lemma rho_identification (hr : d.RealProjections) :
+    d.rho=tensorMap d.localChannel d.localChannel (projector (Phi D)) := by
+  rw [Phi_projector,localChannel,tensorMap_smul]
+  simp only [LinearMap.smul_apply,map_smul,smul_smul]
+  rw [← d.choi_real hr]
+  unfold rho
+  congr 1
+  simp only [Fintype.card_fin,Complex.ofReal_inv,Complex.ofReal_natCast,
+    Complex.ofReal_mul,mul_inv,pow_two,mul_assoc]
+  ring
+
+omit [DecidableEq K] [Nonempty K] in
+lemma rho_represented (hr : d.RealProjections) : Represented d.rho := by
+  refine ⟨d.rho_psd,d.rho_trace,D,D,Nat.pos_of_ne_zero (NeZero.ne D),
+    Nat.pos_of_ne_zero (NeZero.ne D),d.localChannel,d.localChannel,Phi D,
+    d.localChannel_ppt.1,?_,d.localChannel_ppt.1,?_,d.rho_identification hr⟩
+  all_goals rw [d.localChannel_input_transpose hr]; exact d.localChannel_ppt.1
+end Data
+
+theorem real_channel {Q K I : Type} [Fintype Q] [Fintype K] [Fintype I]
+    [DecidableEq Q] [DecidableEq K] [DecidableEq I] [Nonempty Q] [Nonempty K]
+    {D : ℕ} [NeZero D] (d : Data Q K (Fin D) I) (hr : d.RealProjections) :
+    (hsAdjoint d.Psi).comp transposeMap=hsAdjoint d.Psi ∧
+    transposeMap.comp (hsAdjoint d.Psi)=hsAdjoint d.Psi ∧
+    (∀ A, Matrix.trace (hsAdjoint d.Psi A)=(Fintype.card Q : ℂ)*Matrix.trace A) ∧
+    PPT d.localChannel ∧ TracePreserving d.localChannel ∧
+    d.rho=tensorMap d.localChannel d.localChannel (projector (Phi D)) ∧
+    Represented d.rho ∧ ¬ Separable d.rho := by
+  exact ⟨d.adjoint_input_transpose hr,d.adjoint_output_transpose,d.adjoint_trace,
+    d.localChannel_ppt,d.localChannel_tp,d.rho_identification hr,d.rho_represented hr,
+    d.rho_nonseparable⟩
+
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionReindex.lean

@@ -0,0 +1,73 @@
+import OAI.InformationTheory.Entanglement.ProjectionData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion
+variable {Q K D I D' I' : Type} [Fintype Q] [Fintype K] [Fintype D] [Fintype I]
+  [Fintype D'] [Fintype I'] [DecidableEq Q] [DecidableEq K] [DecidableEq D]
+  [DecidableEq I] [DecidableEq D'] [DecidableEq I']
+omit [DecidableEq D] [DecidableEq D'] in
+lemma trace_reindex (e : D' ≃ D) (A : Mat D) :
+    Matrix.trace (A.submatrix e e)=Matrix.trace A :=
+  e.sum_comp (fun i => A i i)
+namespace Data
+variable (d : Data Q K D I) (eD : D' ≃ D) (eI : I' ≃ I)
+def reindexP (i : I') : Mat D' := (d.P (eI i)).submatrix eD eD
+omit [Fintype I'] [DecidableEq K] [DecidableEq I] [DecidableEq D'] [DecidableEq I'] in
+lemma reindexP_overlap (i j : I') :
+    Matrix.trace (d.reindexP eD eI i*d.reindexP eD eI j)=
+      Matrix.trace (d.P (eI i)*d.P (eI j)) := by
+  rw [reindexP,reindexP,Matrix.submatrix_mul_equiv,trace_reindex]
+omit [Fintype D'] [DecidableEq K] [DecidableEq I] [DecidableEq I'] in
+lemma reindexP_complete (q : Q) :
+    ∑ i : I' with d.question (eI i)=q, d.reindexP eD eI i=1 := by
+  rw [Finset.sum_filter]
+  calc
+    _ = ∑ i : I, if d.question i=q then (d.P i).submatrix eD eD else 0 :=
+      eI.sum_comp _
+    _ = (∑ i : I with d.question i=q, d.P i).submatrix eD eD := by
+      ext a b
+      simp only [Matrix.sum_apply,Matrix.submatrix_apply,Finset.sum_filter]
+      apply Finset.sum_congr rfl
+      intro c hc
+      split_ifs <;> rfl
+    _ = 1 := by rw [d.complete,Matrix.submatrix_one_equiv]
+omit [Fintype I'] [DecidableEq K] [DecidableEq D'] [DecidableEq I'] in
+lemma reindexP_clique (J : Finset I')
+    (hJ : ∀ i ∈ J, ∀ j ∈ J, i ≠ j → 0 < (Matrix.trace (d.reindexP eD eI i*d.reindexP eD eI j)).re) :
+    (J.card : ℝ) ≤ d.κ := by
+  have hh := d.clique (J.image eI) (by
+    intro i hi j hj hij
+    obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hi
+    obtain ⟨b,hb,rfl⟩ := Finset.mem_image.mp hj
+    rw [← d.reindexP_overlap eD eI]
+    exact hJ a ha b hb (fun he => hij (he ▸ rfl)))
+  simpa only [Finset.card_image_of_injective _ eI.injective] using hh
+
+def reindex : Data Q K D' I' where
+  question i := d.question (eI i)
+  u := d.u
+  unit := d.unit
+  P := d.reindexP eD eI
+  hermitian i := (d.hermitian (eI i)).submatrix eD
+  idempotent i := by rw [reindexP,Matrix.submatrix_mul_equiv,d.idempotent]
+  orthogonal i j hq hij := by
+    rw [reindexP,reindexP,Matrix.submatrix_mul_equiv,
+      d.orthogonal (eI i) (eI j) hq (eI.injective.ne hij)]
+    rfl
+  complete := d.reindexP_complete eD eI
+  commute i j h := by
+    rw [reindexP,reindexP,Matrix.submatrix_mul_equiv,Matrix.submatrix_mul_equiv,d.commute _ _ h]
+  κ := d.κ
+  gap := d.gap
+  clique := d.reindexP_clique eD eI
+end Data
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionSquare.lean

@@ -0,0 +1,73 @@
+import OAI.InformationTheory.Entanglement.ProjectionMain
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion
+
+lemma hsAdjoint_left_ad {n m p : Type} [Fintype n] [Fintype m] [Fintype p]
+    [DecidableEq n] {F : Map n m} (hF : CP F) (S : Matrix p m ℂ) :
+    hsAdjoint ((ad S).comp F)=(hsAdjoint F).comp (ad Sᴴ) := by
+  ext X i j
+  have he (Y : Mat n) : Matrix.trace (Y*hsAdjoint ((ad S).comp F) X)=
+      Matrix.trace (Y*hsAdjoint F (ad Sᴴ X)) := by
+    rw [trace_hsAdjoint (cp_comp (cp_ad S) hF),trace_hsAdjoint hF]
+    simp only [LinearMap.comp_apply,ad_apply,Matrix.conjTranspose_conjTranspose]
+    calc
+      Matrix.trace (S*F Y*Sᴴ*X)=Matrix.trace (S*(F Y*Sᴴ*X)) := by simp only [Matrix.mul_assoc]
+      _ = Matrix.trace ((F Y*Sᴴ*X)*S) := Matrix.trace_mul_comm _ _
+      _ = _ := by simp only [Matrix.mul_assoc]
+  change hsAdjoint ((ad S).comp F) X i j=hsAdjoint F (ad Sᴴ X) i j
+  simpa only [Matrix.trace_single_mul,one_smul] using he (Matrix.single j i 1)
+
+namespace Data
+variable {Q K : Type} [Fintype Q] [Fintype K] [DecidableEq Q] [DecidableEq K]
+  {D n : ℕ} (d : Data Q K (Fin D) (Fin n)) (h : D ≤ n)
+
+def firstCoordinates (_d : Data Q K (Fin D) (Fin n)) (h : D ≤ n) :
+    Matrix (Fin n) (Fin D) ℂ := coord (Fin.castLE h)
+def Xi1 : Map (Fin n) (Fin n) := (ad (d.firstCoordinates h)).comp d.Psi
+def Xi2 : Map (Fin n) (Fin n) := (hsAdjoint d.Psi).comp (ad (d.firstCoordinates h)ᴴ)
+
+omit [DecidableEq K] in
+lemma Xi1_ppt : PPT (d.Xi1 h) := ppt_ad_comp d.Psi_ppt _
+omit [DecidableEq K] in
+lemma Xi2_ppt : PPT (d.Xi2 h) := ppt_comp_cp d.adjoint_ppt (cp_ad _)
+omit [DecidableEq K] in
+lemma Xi2_adjoint : d.Xi2 h=hsAdjoint (d.Xi1 h) := (hsAdjoint_left_ad d.Psi_cp _).symm
+omit [DecidableEq K] in
+lemma Xi_composite : (d.Xi2 h).comp (d.Xi1 h)=(hsAdjoint d.Psi).comp d.Psi := by
+  ext X a b
+  simp only [Xi1,Xi2,LinearMap.comp_apply,ad_apply,Matrix.conjTranspose_conjTranspose]
+  have hh : (d.firstCoordinates h)ᴴ*d.firstCoordinates h=1 :=
+    coord_isometry _ (Fin.castLE_injective h)
+  have he : (d.firstCoordinates h)ᴴ*((d.firstCoordinates h)*d.Psi X*(d.firstCoordinates h)ᴴ)*
+      (d.firstCoordinates h)=d.Psi X := by
+    calc
+      _ = ((d.firstCoordinates h)ᴴ*d.firstCoordinates h)*d.Psi X*
+          ((d.firstCoordinates h)ᴴ*d.firstCoordinates h) := by simp only [Matrix.mul_assoc]
+      _ = _ := by rw [hh,Matrix.one_mul,Matrix.mul_one]
+  rw [he]
+lemma Xi_not_eb [Nonempty Q] [Nonempty K] [NeZero D] :
+    ¬ EntanglementBreaking ((d.Xi2 h).comp (d.Xi1 h)) := by
+  intro heb
+  rw [d.Xi_composite h] at heb
+  exact d.C_nonseparable (eb_choi heb)
+end Data
+
+theorem square_embedding {Q K : Type} [Fintype Q] [Fintype K]
+    [DecidableEq Q] [DecidableEq K] [Nonempty Q] [Nonempty K]
+    {D n : ℕ} [NeZero D] (d : Data Q K (Fin D) (Fin n)) (h : D ≤ n) :
+    PPT (d.Xi1 h) ∧ PPT (d.Xi2 h) ∧ d.Xi2 h=hsAdjoint (d.Xi1 h) ∧
+    (d.Xi2 h).comp (d.Xi1 h)=(hsAdjoint d.Psi).comp d.Psi ∧
+    ¬ EntanglementBreaking ((d.Xi2 h).comp (d.Xi1 h)) := by
+  exact ⟨d.Xi1_ppt h,d.Xi2_ppt h,d.Xi2_adjoint h,d.Xi_composite h,d.Xi_not_eb h⟩
+
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ProjectionStats.lean

@@ -0,0 +1,104 @@
+import OAI.InformationTheory.Entanglement.ProjectionData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion
+namespace Data
+variable {Q K D I : Type} [Fintype Q] [Fintype K] [Fintype D] [Fintype I]
+  [DecidableEq Q] [DecidableEq D] [DecidableEq I]
+variable (d : Data Q K D I)
+
+lemma adjoint_apply (A : Mat D) (i j : I) :
+    hsAdjoint d.Psi A i j = Matrix.trace ((d.H i j)ᴴ * A) := by
+  simp only [hsAdjoint,d.Psi_single]
+  change (∑ a, ∑ b, star (d.H i j a b)*A a b) =
+    ∑ a, ∑ b, star (d.H i j b a)*A b a
+  rw [Finset.sum_comm]
+lemma C_entry (i j a b : I) : d.C (i,a) (j,b) = Matrix.trace ((d.H a b)ᴴ*d.H i j) := by
+  change hsAdjoint d.Psi (d.Psi (Matrix.single i j 1)) a b = _
+  rw [d.Psi_single,d.adjoint_apply]
+lemma C_diag (i j : I) : d.C (i,j) (i,j) = Matrix.trace (d.P i*d.P j) := by
+  rw [d.C_entry,d.H_self,d.H_self,(d.hermitian j).eq,Matrix.trace_mul_comm]
+omit [DecidableEq I] in
+lemma overlap_gram (i j : I) :
+    Matrix.trace ((d.P i*d.P j)ᴴ*(d.P i*d.P j))=Matrix.trace (d.P i*d.P j) := by
+  rw [Matrix.conjTranspose_mul,(d.hermitian i).eq,(d.hermitian j).eq]
+  calc
+    Matrix.trace (d.P j*d.P i*(d.P i*d.P j)) =
+        Matrix.trace (d.P j*(d.P i*d.P i)*d.P j) := by simp only [Matrix.mul_assoc]
+    _ = Matrix.trace (d.P j*d.P i*d.P j) := by rw [d.idempotent]
+    _ = Matrix.trace (d.P j*d.P j*d.P i) := Matrix.trace_mul_cycle _ _ _
+    _ = Matrix.trace (d.P i*d.P j) := by rw [d.idempotent,Matrix.trace_mul_comm]
+omit [DecidableEq I] in
+lemma overlap_nonneg (i j : I) : 0 ≤ (Matrix.trace (d.P i*d.P j)).re := by
+  rw [← d.overlap_gram]
+  exact (Complex.nonneg_iff.mp (Matrix.posSemidef_conjTranspose_mul_self (d.P i*d.P j)).trace_nonneg).1
+omit [DecidableEq I] in
+lemma overlap_im (i j : I) : (Matrix.trace (d.P i*d.P j)).im=0 := by
+  rw [← d.overlap_gram]
+  exact (Complex.nonneg_iff.mp (Matrix.posSemidef_conjTranspose_mul_self (d.P i*d.P j)).trace_nonneg).2.symm
+lemma B_entry (i j : I) : d.B i j = ((d.c i j)^2 : ℂ) * Matrix.trace (d.P i*d.P j) := by
+  change d.C (i,i) (j,j) = _
+  rw [d.C_entry]
+  simp only [H,Matrix.conjTranspose_smul,Complex.star_def,Complex.conj_ofReal,
+    Matrix.smul_mul,Matrix.mul_smul,smul_smul,Matrix.trace_smul,smul_eq_mul]
+  rw [d.overlap_gram]
+  ring
+omit [DecidableEq I] in
+lemma weighted_trace (f : Q → ℂ) (A : Mat D) :
+    (∑ i, f (d.question i)*Matrix.trace (A*d.P i)) =
+      (∑ q, f q)*Matrix.trace A := by
+  rw [← Finset.sum_fiberwise Finset.univ d.question]
+  calc
+    (∑ q, ∑ i with d.question i=q, f (d.question i)*Matrix.trace (A*d.P i)) =
+        ∑ q, f q * Matrix.trace A := by
+      apply Finset.sum_congr rfl
+      intro q _
+      calc
+        (∑ i with d.question i=q, f (d.question i)*Matrix.trace (A*d.P i)) =
+            ∑ i with d.question i=q, f q*Matrix.trace (A*d.P i) := by
+          apply Finset.sum_congr rfl
+          intro i hi
+          rw [(Finset.mem_filter.mp hi).2]
+        _ = f q*Matrix.trace (A*(∑ i with d.question i=q, d.P i)) := by
+          simp only [Matrix.trace_sum,Finset.mul_sum]
+        _ = f q*Matrix.trace A := by rw [d.complete,Matrix.mul_one]
+    _ = _ := (Finset.sum_mul ..).symm
+omit [DecidableEq I] in
+lemma weighted_projector_trace (f : Q → ℂ) :
+    (∑ i, f (d.question i)*Matrix.trace (d.P i)) =
+      (∑ q, f q)*(Fintype.card D : ℂ) := by
+  simpa only [Matrix.one_mul,Matrix.trace_one] using d.weighted_trace f 1
+omit [DecidableEq I] in
+lemma weighted_overlap (f : Q → Q → ℂ) :
+    (∑ i, ∑ j, f (d.question i) (d.question j)*Matrix.trace (d.P i*d.P j)) =
+      (∑ q, ∑ r, f q r)*(Fintype.card D : ℂ) := by
+  simp_rw [d.weighted_trace]
+  exact d.weighted_projector_trace (fun q => ∑ r, f q r)
+lemma C_trace : Matrix.trace d.C = (Fintype.card Q : ℂ)^2*(Fintype.card D : ℂ) := by
+  change (∑ ij, d.C ij ij) = _
+  rw [Fintype.sum_prod_type]
+  simp_rw [d.C_diag]
+  have h := d.weighted_overlap (fun _ _ => 1)
+  simpa only [one_mul,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one,pow_two] using h
+lemma B_trace : Matrix.trace d.B = (Fintype.card Q : ℂ)*(Fintype.card D : ℂ) := by
+  change (∑ i, d.C (i,i) (i,i)) = _
+  simp_rw [d.C_diag,d.idempotent]
+  have h := d.weighted_projector_trace (fun _ => 1)
+  simpa only [one_mul,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] using h
+lemma B_sum : (∑ i, ∑ j, d.B i j) =
+    ((∑ q, ∑ r, (correlation d.u q r)^2 : ℝ) : ℂ)*(Fintype.card D : ℂ) := by
+  simp only [d.B_entry,c]
+  rw [d.weighted_overlap (fun q r => (correlation d.u q r : ℂ)^2)]
+  push_cast
+  rfl
+end Data
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PublicSampler.lean

@@ -0,0 +1,44 @@
+import OAI.InformationTheory.Entanglement.IndependentTapes
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Function
+open scoped MeasureTheory ProbabilityTheory unitInterval
+namespace SecretKey
+variable {Ω S T Y : Type*} {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω]
+variable [MeasurableSpace S] [MeasurableSpace T] [MeasurableSpace Y]
+variable [StandardBorelSpace Y] [Nonempty Y]
+variable {μ : Measure Ω} [IsProbabilityMeasure μ]
+
+omit [StandardBorelSpace Y] [Nonempty Y] in
+theorem sampled_public_independence
+    {F A : MeasurableSpace Ω} (hF : F ≤ mΩ) (_ : A ≤ mΩ)
+    (H : Ω → S) (hH : @Measurable Ω S mΩ _ H)
+    (hFH : F ≤ (inferInstance : MeasurableSpace S).comap H)
+    (hAH : A ≤ (inferInstance : MeasurableSpace S).comap H)
+    (g : S → T) (hg : Measurable g) (hpub : Measurable[F] (g ∘ H))
+    (U : Ω → I) (hU : @Measurable Ω I mΩ _ U) (hind : IndepFun H U μ)
+    (hUlaw : @Measure.map Ω I mΩ _ U μ=volume)
+    (κ : Kernel T Y) [IsMarkovKernel κ]
+    (f : T → I → Y) (hf : Measurable (uncurry f))
+    (hmap : ∀ t, volume.map (f t)=κ t) :
+    CondIndep F A ((inferInstance : MeasurableSpace Y).comap (fun ω => f (g (H ω)) (U ω))) hF μ := by
+  let : MeasurableSpace Ω := mΩ
+  have hC : @Measurable Ω Y mΩ _ (fun ω => f (g (H ω)) (U ω)) :=
+    hf.comp ((hg.comp hH).prodMk hU)
+  apply independent_of_public_conditional_laws hF hH.comap_le hFH hAH hC.comap_le
+  intro b hb
+  obtain ⟨E,hE,rfl⟩ := hb
+  have hs := sampled_conditional_event H U hH hU hind (fun s u => f (g s) u)
+    (hf.comp ((hg.comp measurable_fst).prodMk measurable_snd)) (κ.comap g hg)
+    (by intro s; simpa only [hUlaw,Kernel.comap_apply] using hmap (g s)) E hE
+  have hm : StronglyMeasurable[F] (fun ω => (κ (g (H ω))).real E) := by
+    exact (((κ.measurable_coe hE).comp hpub).ennreal_toReal).stronglyMeasurable
+  exact hm.aestronglyMeasurable.congr hs.symm
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PurificationExpansion.lean

@@ -0,0 +1,41 @@
+import OAI.InformationTheory.Entanglement.PurificationSupport
+import OAI.InformationTheory.Entanglement.HilbertEmbeddingOrder
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators InnerProductSpace ComplexOrder MatrixOrder
+open Matrix ContinuousLinearMap
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {n : Type} [Fintype n] [DecidableEq n]
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+omit [DecidableEq n] [CompleteSpace H] in
+theorem purification_orthonormal_expansion (x : n→H) :
+    ∃ d : ℕ, ∃ v : Fin d→H, ∃ B : Matrix (Fin d) n ℂ,
+      Orthonormal ℂ v ∧ (∀ j, ∑ i, B i j • v i=x j) ∧
+      (∀ i j, (Bᴴ*B) i j=inner ℂ (x i) (x j)) := by
+  obtain ⟨d,V,B,hx,hg⟩ := purification_finite_span x
+  let e := EuclideanSpace.basisFun (Fin d) ℂ
+  let v := fun i => V (e i)
+  have hv : Orthonormal ℂ v := by
+    rw [orthonormal_iff_ite]
+    intro i j
+    rw [show inner ℂ (v i) (v j)=inner ℂ (e i) (e j) from V.inner_map_map _ _]
+    exact orthonormal_iff_ite.mp e.orthonormal i j
+  refine ⟨d,v,B,hv,?_,hg⟩
+  intro j
+  calc
+    _=V (∑ i, B i j • e i) := by simp only [map_sum,map_smul]; rfl
+    _=V (WithLp.toLp 2 (fun i => B i j)) := by
+      congr 1
+      simpa only [e,EuclideanSpace.basisFun_repr,WithLp.ofLp_toLp] using
+        e.sum_repr (WithLp.toLp 2 (fun i => B i j))
+    _=x j := hx j
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/PurificationSupport.lean

@@ -0,0 +1,53 @@
+import OAI.InformationTheory.Entanglement.FiniteRecovery
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators InnerProductSpace ComplexOrder MatrixOrder
+open Matrix
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {n : Type} [Fintype n] [DecidableEq n]
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+
+omit [DecidableEq n] in
+theorem purification_finite_span (x : n → H) :
+    ∃ d : ℕ, ∃ V : EuclideanSpace ℂ (Fin d) →ₗᵢ[ℂ] H,
+      ∃ B : Matrix (Fin d) n ℂ,
+        (∀ j, V (WithLp.toLp 2 (fun a => B a j))=x j) ∧
+        (∀ i j, (Bᴴ*B) i j=inner ℂ (x i) (x j)) := by
+  let S := Submodule.span ℂ (Set.range x)
+  let : FiniteDimensional ℂ S := FiniteDimensional.span_of_finite ℂ (Set.finite_range x)
+  let b := stdOrthonormalBasis ℂ S
+  let v (j : n) : S := ⟨x j,Submodule.subset_span (Set.mem_range_self j)⟩
+  let V : EuclideanSpace ℂ (Fin (Module.finrank ℂ S)) →ₗᵢ[ℂ] H :=
+    S.subtypeₗᵢ.comp b.repr.symm.toLinearIsometry
+  let B : Matrix (Fin (Module.finrank ℂ S)) n ℂ := fun a j => b.repr (v j) a
+  have hv (j : n) : V (WithLp.toLp 2 (fun a => B a j))=x j := by
+    change ↑(b.repr.symm (b.repr (v j)))=x j
+    rw [b.repr.symm_apply_apply]
+  refine ⟨_,V,B,hv,?_⟩
+  intro i j
+  rw [← hv i,← hv j,V.inner_map_map]
+  simp only [EuclideanSpace.inner_eq_star_dotProduct,
+    Matrix.mul_apply,Matrix.conjTranspose_apply,dotProduct,Pi.star_apply,mul_comm]
+
+theorem purification_support_recovery (i₀ : n) (x : n → H) :
+    ∃ d : ℕ, ∃ V : EuclideanSpace ℂ (Fin d) →ₗᵢ[ℂ] H,
+      ∃ B : Matrix (Fin d) n ℂ, ∃ F : Map (Fin d) n,
+        CP F ∧ TracePreserving F ∧
+        (∀ j, V (WithLp.toLp 2 (fun a => B a j))=x j) ∧
+        (∀ A : Mat n, F (B*A*Bᴴ)=
+          CFC.sqrt (Matrix.of fun i j => inner ℂ (x i) (x j))*A*CFC.sqrt (Matrix.of fun i j => inner ℂ (x i) (x j))) := by
+  obtain ⟨d,V,B,hx,hgram⟩ := purification_finite_span x
+  obtain ⟨F,hF,hT,hrec⟩ := finite_purification_recovery i₀ B
+  have he : Bᴴ*B=Matrix.of (fun i j => inner ℂ (x i) (x j)) := by ext i j; exact hgram i j
+  refine ⟨d,V,B,F,hF,hT,hx,?_⟩
+  intro A
+  simpa only [he] using hrec A
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/QuantumStepKernel.lean

@@ -0,0 +1,55 @@
+import OAI.InformationTheory.Entanglement.ProductInstrumentStep
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators InnerProductSpace ComplexOrder ENNReal MeasureTheory TensorProduct
+open ContinuousLinearMap MeasureTheory ProbabilityTheory
+namespace SecretKey
+variable {S X : Type*} [MeasurableSpace S] [MeasurableSpace X]
+lemma compProd_real_rectangle (ν : Measure S) [IsFiniteMeasure ν] (K : Kernel S X)
+    [IsMarkovKernel K] {U : Set S} {V : Set X} (hU : MeasurableSet U) (hV : MeasurableSet V) :
+    (ν ⊗ₘ K).real (U ×ˢ V)=∫ h in U, (K h).real V ∂ν := by
+  rw [Measure.real,Measure.compProd_apply_prod hU hV]
+  exact (integral_toReal (K.measurable_coe hV).aemeasurable
+    (Filter.Eventually.of_forall (fun h => measure_lt_top (K h) V))).symm
+variable {H K L : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+  [NormedAddCommGroup L] [InnerProductSpace ℂ L] [CompleteSpace L]
+variable {ι κ υ : Type*}
+
+omit [CompleteSpace H] [CompleteSpace L] in
+theorem quantum_step_kernel (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (J : S→TraceInstrument b c X)
+    (ρ : S→DensityOperator b) (σ : S→DensityOperator d)
+    (hm : ∀ V, MeasurableSet V → Measurable (fun h => (J h).outcome (ρ h) V))
+    (ν : Measure S) [IsFiniteMeasure ν] (ν' : Measure (S×X)) [IsFiniteMeasure ν']
+    (hBorn : ∀ U V, MeasurableSet U → MeasurableSet V →
+      ν'.real (U ×ˢ V)=∫ h in U,
+        (tensorFunctional (traceClassTrace c) (traceClassTrace d)
+          (TensorProduct.map ((J h).event V) LinearMap.id ((ρ h).val ⊗ₜ[ℂ] (σ h).val))).re ∂ν) :
+    ν'=ν ⊗ₘ TraceInstrument.historyKernel J ρ hm := by
+  apply Measure.ext_prod
+  intro U V hU hV
+  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
+  change ν'.real (U ×ˢ V)=(ν ⊗ₘ TraceInstrument.historyKernel J ρ hm).real (U ×ˢ V)
+  rw [hBorn U V hU hV,compProd_real_rectangle ν _ hU hV]
+  apply setIntegral_congr_fun hU
+  intro h hh
+  exact local_product_born b c d (J h) (ρ h) (σ h) hV
+
+omit [CompleteSpace H] [CompleteSpace L] in
+lemma right_product_born (b : HilbertBasis ι ℂ H) (c : HilbertBasis κ ℂ K)
+    (d : HilbertBasis υ ℂ L) (I : TraceInstrument b c X)
+    (ρ : DensityOperator b) (σ : DensityOperator d) {V : Set X} (hV : MeasurableSet V) :
+    (tensorFunctional (traceClassTrace d) (traceClassTrace c)
+      (TensorProduct.map LinearMap.id (I.event V) (σ.val ⊗ₜ[ℂ] ρ.val))).re=(I.outcome ρ).real V := by
+  rw [TensorProduct.map_tmul,tensorFunctional_tmul,LinearMap.id_apply,σ.property.2,one_mul,
+    I.outcome_born ρ hV]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ReferenceFilter.lean

@@ -0,0 +1,92 @@
+import OAI.InformationTheory.Entanglement.MatrixTraceMeasure
+import OAI.InformationTheory.Entanglement.ProbeMatrices
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder MeasureTheory Kronecker
+open Matrix MeasureTheory
+namespace SecretKey
+open ChannelCompletion
+variable {Ω : Type*} [MeasurableSpace Ω]
+variable {n m : Type} [Fintype n] [Fintype m] [DecidableEq n] [DecidableEq m]
+namespace PositiveMatrixMeasure
+omit [Fintype m] [DecidableEq n] [DecidableEq m] in
+lemma filter_entry_value (W : PositiveMatrixMeasure Ω n) (K : Matrix m n ℂ) (s : Set Ω) :
+    (fun a b => (∑ i, ∑ j, (K a i*star (K b j)) • W.entry i j) s)=K*W.value s*Kᴴ := by
+  ext a b
+  simp only [_root_.sum_apply,_root_.smul_apply,smul_eq_mul,Matrix.mul_apply,
+    Matrix.conjTranspose_apply,Finset.sum_mul,value]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i hi
+  apply Finset.sum_congr rfl
+  intro j hj
+  ring
+
+def filter (W : PositiveMatrixMeasure Ω n) (K : Matrix m n ℂ) : PositiveMatrixMeasure Ω m where
+  entry a b := ∑ i, ∑ j, (K a i*star (K b j)) • W.entry i j
+  positive s hs := by
+    rw [filter_entry_value]
+    exact (W.positive s hs).mul_mul_conjTranspose_same K
+omit [DecidableEq n] [DecidableEq m] in
+lemma filter_value (W : PositiveMatrixMeasure Ω n) (K : Matrix m n ℂ) (s : Set Ω) :
+    (W.filter K).value s=K*W.value s*Kᴴ := filter_entry_value W K s
+end PositiveMatrixMeasure
+omit [Fintype m] [DecidableEq n] [DecidableEq m] in
+lemma filter_density_integrable {μ : Measure Ω} {D : Ω → Mat n}
+    (hD : ∀ a b, Integrable (fun x => D x a b) μ) (K : Matrix m n ℂ) (a b : m) :
+    Integrable (fun x => (K*D x*Kᴴ) a b) μ := by
+  simp only [Matrix.mul_apply,Finset.sum_mul]
+  exact integrable_finsetSum _ fun j _ => integrable_finsetSum _ fun i _ =>
+    ((hD i j).const_mul _).mul_const _
+omit [Fintype m] [DecidableEq n] [DecidableEq m] in
+lemma filter_density_measurable {D : Ω → Mat n} (hD : Measurable D) (K : Matrix m n ℂ) :
+    Measurable (fun x => K*D x*Kᴴ) := by
+  have hc : Continuous (fun M : Mat n => K*M*Kᴴ) := by fun_prop
+  exact hc.measurable.comp hD
+omit [DecidableEq n] [DecidableEq m] in
+lemma filter_setIntegral {μ : Measure Ω} (W : PositiveMatrixMeasure Ω n) (K : Matrix m n ℂ)
+    (D : Ω → Mat n) (hD : ∀ a b, Integrable (fun x => D x a b) μ)
+    (hs : ∀ s, MeasurableSet s → ∀ a b, (∫ x in s, D x a b ∂μ)=W.value s a b)
+    {s : Set Ω} (hsm : MeasurableSet s) (a b : m) :
+    (∫ x in s, (K*D x*Kᴴ) a b ∂μ)=(W.filter K).value s a b := by
+  rw [PositiveMatrixMeasure.filter_value]
+  simp only [Matrix.mul_apply,Finset.sum_mul]
+  rw [integral_finsetSum]
+  · apply Finset.sum_congr rfl
+    intro j hj
+    rw [integral_finsetSum]
+    · apply Finset.sum_congr rfl
+      intro i hi
+      rw [integral_mul_const,integral_const_mul, hs s hsm]
+    · intro i hi
+      exact (((hD i j).const_mul _).mul_const _).integrableOn
+  · intro j hj
+    exact (integrable_finsetSum _ fun i _ => ((hD i j).const_mul _).mul_const _).integrableOn
+
+def canonicalProbeFilter (R : Mat (n×m)) : Mat (n×m) :=
+  (Real.sqrt ((Fintype.card n : ℝ)*Fintype.card m) : ℂ) • (CFC.sqrt R)ᵀ
+lemma canonicalProbeFilter_hermitian (R : Mat (n×m)) :
+    (canonicalProbeFilter R)ᴴ=canonicalProbeFilter R := by
+  unfold canonicalProbeFilter
+  rw [Matrix.conjTranspose_smul,Complex.star_def,Complex.conj_ofReal]
+  exact congrArg (_ • ·) (sqrt_psd R).isHermitian.transpose.eq
+lemma canonicalProbeFilter_product (R : Mat (n×m)) (U : Mat n) (V : Mat m) :
+    canonicalProbeFilter R*(U ⊗ₖ V)*(canonicalProbeFilter R)ᴴ =
+      eveBlock R (((Fintype.card n : ℂ) • Uᵀ) ⊗ₖ ((Fintype.card m : ℂ) • Vᵀ)) := by
+  rw [canonicalProbeFilter_hermitian]
+  unfold canonicalProbeFilter eveBlock
+  simp only [Matrix.smul_mul,Matrix.mul_smul,smul_smul]
+  rw [← Complex.ofReal_mul,Real.mul_self_sqrt (by positivity)]
+  simp only [Complex.ofReal_mul,Complex.ofReal_natCast]
+  rw [Matrix.smul_kronecker,Matrix.kronecker_smul,smul_smul,Matrix.mul_smul,Matrix.smul_mul,
+    Matrix.transpose_smul,Matrix.transpose_mul,Matrix.transpose_mul,Matrix.kroneckerMap_transpose,
+    Matrix.transpose_transpose]
+  simp only [Matrix.mul_assoc]
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/RestrictedIntersections.lean

@@ -0,0 +1,67 @@
+import OAI.InformationTheory.Entanglement.BooleanSpan
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+namespace FiniteConstruction
+
+abbrev Base := {A : Finset (Fin 1028) // A.card=514 ∧ (0 : Fin 1028) ∈ A}
+def b : ℕ := Nat.choose 1027 513
+def a₀ : ℕ := ∑ j ∈ Finset.range 257, Nat.choose 1028 j
+instance prime257 : Fact (Nat.Prime 257) := ⟨by norm_num⟩
+
+lemma sum_monomial_apply {α β : Type} [Fintype α] [Fintype β]
+    [DecidableEq α] [DecidableEq β] (B : β → Finset α) (A : Finset α) (c : β) :
+    (∑ a ∈ A, monomial (𝔽 := ZMod 257) B {a}) c=((A ∩ B c).card : ZMod 257) := by
+  simp only [Finset.sum_apply,monomial,Finset.singleton_subset_iff]
+  simp
+
+theorem restricted_intersections (F : Finset Base)
+    (h : ∀ A ∈ F, ∀ B ∈ F, A ≠ B → (A.val ∩ B.val).card ≠ 257) :
+    F.card ≤ a₀ := by
+  let B : F → Finset (Fin 1028) := fun A => A.val.val
+  have hm (A : F) : Pi.single A (1 : ZMod 257) ∈ lowDegree B 256 := by
+    have hc : (1 : F → ZMod 257) ∈ lowDegree B 256 := by
+      simpa only [monomial_empty] using
+        monomial_mem (𝔽 := ZMod 257) B (s := ∅) (d := 256) (by simp)
+    have hp := sum_power_mem (𝔽 := ZMod 257) B (B A) 256
+    have hd := Submodule.sub_mem (lowDegree (𝔽 := ZMod 257) B 256) hc hp
+    convert hd using 1
+    ext C
+    simp only [Pi.single_apply,Pi.sub_apply,Pi.one_apply,Pi.pow_apply,sum_monomial_apply]
+    by_cases he : C=A
+    · subst C
+      have hcard : (B A).card=514 := A.val.property.1
+      simp [hcard,show (514 : ZMod 257)=0 by decide]
+    · have hne : A.val ≠ C.val := by intro hh; exact he (Subtype.ext hh.symm)
+      have hsets : B A ≠ B C := by intro hh; exact hne (Subtype.ext hh)
+      have hpos : 0 < (B A ∩ B C).card := Finset.card_pos.mpr ⟨0,
+        Finset.mem_inter.mpr ⟨A.val.property.2,C.val.property.2⟩⟩
+      have hle : (B A ∩ B C).card ≤ 514 := by
+        simpa only [show (B A).card=514 from A.val.property.1] using
+          Finset.card_le_card (Finset.inter_subset_left : B A ∩ B C ⊆ B A)
+      have hlt : (B A ∩ B C).card < 514 := by
+        by_contra hn
+        have ha : B A ∩ B C=B A := Finset.eq_of_subset_of_card_le
+          Finset.inter_subset_left (by rw [A.val.property.1]; omega)
+        have hb : B A ∩ B C=B C := Finset.eq_of_subset_of_card_le
+          Finset.inter_subset_right (by rw [C.val.property.1]; omega)
+        exact hsets (ha.symm.trans hb)
+      have hx : (B A ∩ B C).card ≠ 257 := h A.val A.property C.val C.property hne
+      have hnz : ((B A ∩ B C).card : ZMod 257) ≠ 0 := by
+        intro hz
+        have hdvd := (ZMod.natCast_eq_zero_iff (B A ∩ B C).card 257).mp hz
+        obtain ⟨t,ht⟩ := hdvd
+        omega
+      have hpw := ZMod.pow_card_sub_one_eq_one hnz
+      norm_num at hpw
+      simp only [he,ite_false,hpw,sub_self]
+  have hdim := interpolation_dimension_bound (𝔽 := ZMod 257) B 256 hm
+  simpa only [Fintype.card_coe,Fintype.card_fin,show 256+1=257 by rfl,a₀] using hdim
+
+end FiniteConstruction
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/ScalarGap.lean

@@ -0,0 +1,69 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory
+open scoped BigOperators
+namespace SecretKey
+variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
+lemma sqrt_memLp_two {p : Ω → ℝ} (hp : Integrable p μ) (hn : ∀ x, 0≤p x) :
+    MemLp (fun x => Real.sqrt (p x)) 2 μ := by
+  apply (memLp_two_iff_integrable_sq hp.1.aemeasurable.sqrt.aestronglyMeasurable).mpr
+  simpa only [Real.sq_sqrt (hn _)] using hp
+lemma sqrt_product_integrable {p q : Ω → ℝ} (hp : Integrable p μ) (hq : Integrable q μ)
+    (hn : ∀ x, 0≤p x) (hm : ∀ x, 0≤q x) : Integrable (fun x => Real.sqrt (p x*q x)) μ := by
+  have hi := (sqrt_memLp_two hp hn).integrable_mul (sqrt_memLp_two hq hm)
+  simpa only [Pi.mul_def,Real.sqrt_mul (hn _)] using hi
+lemma integral_sqrt_product_le {p q : Ω → ℝ} (hp : Integrable p μ) (hq : Integrable q μ)
+    (hn : ∀ x, 0≤p x) (hm : ∀ x, 0≤q x) :
+    (∫ x, Real.sqrt (p x*q x) ∂μ) ≤ Real.sqrt ((∫ x, p x ∂μ)*(∫ x, q x ∂μ)) := by
+  have hh : (2 : ℝ).HolderConjugate 2 := by norm_num [Real.holderConjugate_iff]
+  have h := integral_mul_le_Lp_mul_Lq_of_nonneg hh
+    (f := fun x => Real.sqrt (p x)) (g := fun x => Real.sqrt (q x))
+    (Filter.Eventually.of_forall fun _ => Real.sqrt_nonneg _)
+    (Filter.Eventually.of_forall fun _ => Real.sqrt_nonneg _)
+    (by simpa using sqrt_memLp_two hp hn) (by simpa using sqrt_memLp_two hq hm)
+  simpa only [Real.rpow_two,Real.sq_sqrt (hn _),Real.sq_sqrt (hm _),
+    ← Real.sqrt_eq_rpow,Real.sqrt_mul (hn _),
+    Real.sqrt_mul (integral_nonneg hn)] using h
+
+lemma two_sqrt_products_le {a b c d : ℝ} (ha : 0≤a) (hb : 0≤b) (hc : 0≤c) (hd : 0≤d) :
+    Real.sqrt (a*b)+Real.sqrt (c*d) ≤ Real.sqrt ((a+d)*(b+c)) := by
+  have h := Real.sum_sqrt_mul_sqrt_le (Finset.univ : Finset (Fin 2))
+    (f := ![a,d]) (g := ![b,c]) (by intro i; fin_cases i <;> assumption)
+    (by intro i; fin_cases i <;> assumption)
+  simpa only [Fin.sum_univ_two,Matrix.cons_val_zero,Matrix.cons_val_one,
+    Matrix.cons_val_fin_one,← Real.sqrt_mul ha,← Real.sqrt_mul hd,
+    ← Real.sqrt_mul (add_nonneg ha hd),mul_comm d c] using h
+lemma two_sqrt_le_add {a b : ℝ} (ha : 0≤a) (hb : 0≤b) : 2*Real.sqrt (a*b)≤a+b := by
+  have hs := Real.sq_sqrt (mul_nonneg ha hb)
+  have hn := Real.sqrt_nonneg (a*b)
+  nlinarith [sq_nonneg (a-b)]
+
+theorem scalar_secret_bit_gap {a b c d q η : ℝ}
+    (ha : 0≤a) (hb : 0≤b) (hc : 0≤c) (hd : 0≤d)
+    (hs : a+b+c+d=1) (he : b+c≤η/2) (hq : q≤η-(b+c))
+    (hf : (a+d-q)/2≤Real.sqrt (a*b)+Real.sqrt (c*d)+2*Real.sqrt (b*c)) :
+    1/5≤η := by
+  have hu := add_le_add (two_sqrt_products_le ha hb hc hd) (two_sqrt_le_add hb hc)
+  have hlow : (1-η)/2≤Real.sqrt ((b+c)*(1-(b+c)))+(b+c) := by
+    have hx : (a+d)*(b+c)=(b+c)*(1-(b+c)) := by nlinarith [hs]
+    rw [hx] at hu
+    linarith
+  by_contra hh
+  have heta : η<1/5 := lt_of_not_ge hh
+  have en : 0≤b+c := add_nonneg hb hc
+  have eb : b+c<1/10 := by linarith
+  have eone : 0≤1-(b+c) := by linarith
+  have hr := Real.sq_sqrt (mul_nonneg en eone)
+  have sr := Real.sqrt_nonneg ((b+c)*(1-(b+c)))
+  have hprod : (b+c)*(1-(b+c))≤9/100 := by
+    nlinarith [mul_nonneg en (by linarith : 0≤1/10-(b+c))]
+  have hsqrt : Real.sqrt ((b+c)*(1-(b+c)))≤3/10 := by nlinarith
+  linarith
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/SecretDefinitions.lean

@@ -0,0 +1,32 @@
+import OAI.Analysis.Quantum.PPTSquare.ChannelModel
+import OAI.Analysis.Quantum.PPTSquare.Compression
+import OAI.Analysis.Quantum.PPTSquare.TensorModel
+import OAI.Analysis.Quantum.PPTSquare.TensorPositivity
+import OAI.Analysis.Quantum.PPTSquare.SymmetricVectors
+import OAI.Analysis.Quantum.PPTSquare.QuadraticCriterion
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder Kronecker MatrixOrder
+open Matrix
+namespace SecretKey
+open ChannelCompletion TensorCriterion
+variable {n m : Type} [Fintype n] [Fintype m]
+
+noncomputable def traceNorm (A : Matrix n m ℂ) : ℝ := by
+  classical
+  exact (Matrix.trace (CFC.sqrt (Aᴴ * A))).re
+
+def Represented (R : Mat (n × m)) : Prop :=
+  R.PosSemidef ∧ Matrix.trace R = 1 ∧
+  ∃ r s : ℕ, 0 < r ∧ 0 < s ∧
+    ∃ (L : Map (Fin r) n) (M : Map (Fin s) m) (χ : Fin r × Fin s → ℂ),
+      CP L ∧ CP (L.comp transposeMap) ∧ CP M ∧ CP (M.comp transposeMap) ∧
+      R = tensorMap L M (Matrix.vecMulVec χ (star χ))
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/SequentialSampling.lean

@@ -0,0 +1,172 @@
+import OAI.InformationTheory.Entanglement.IndependentTapes
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Function
+open scoped MeasureTheory ProbabilityTheory unitInterval
+namespace SecretKey
+variable {Ω S X : Type*} [MeasurableSpace Ω] [MeasurableSpace S]
+  [MeasurableSpace X]
+variable {μ : Measure Ω} [IsProbabilityMeasure μ]
+
+theorem sampled_pair_law (H : Ω → S) (U : Ω → I)
+    (hH : Measurable H) (hU : Measurable U) (hind : IndepFun H U μ)
+    (hUlaw : μ.map U=volume) (κ : Kernel S X) [IsMarkovKernel κ]
+    (f : S → I → X) (hf : Measurable (uncurry f))
+    (hmap : ∀ s, volume.map (f s)=κ s) :
+    μ.map (fun ω => (H ω,f (H ω) (U ω)))=μ.map H ⊗ₘ κ := by
+  let g : S×I → S×X := fun p => (p.1,f p.1 p.2)
+  have hg : Measurable g := measurable_fst.prodMk hf
+  have he : μ.map (fun ω => (H ω,f (H ω) (U ω)))=
+      ((μ.map H).prod volume).map g := by
+    rw [← hUlaw,← hind.map_prod_eq_prod_map_map hH.aemeasurable hU.aemeasurable,
+      Measure.map_map hg (hH.prodMk hU)]
+    rfl
+  rw [he]
+  ext E hE
+  rw [Measure.map_apply hg hE,Measure.prod_apply (hg hE),Measure.compProd_apply hE]
+  apply lintegral_congr
+  intro s
+  have hm : Measurable (f s) := hf.comp (measurable_const.prodMk measurable_id)
+  rw [← hmap s,Measure.map_apply hm (measurable_prodMk_left hE)]
+  rfl
+
+variable (f : (k : ℕ) → (Fin k → X) → I → X)
+
+def sampledPrefix : (k : ℕ) → UniformTapes ℕ → (Fin k → X)
+  | 0,_ => Fin.elim0
+  | k+1,ω => Fin.snoc (sampledPrefix k ω) (f k (sampledPrefix k ω) (ω k))
+def sampledHistory (ω : UniformTapes ℕ) (k : ℕ) : X :=
+  f k (sampledPrefix f k ω) (ω k)
+omit [MeasurableSpace X] in
+lemma sampledPrefix_succ (k : ℕ) (ω : UniformTapes ℕ) :
+    sampledPrefix f (k+1) ω=Fin.snoc (sampledPrefix f k ω) (sampledHistory f ω k) := rfl
+omit [MeasurableSpace X] in
+lemma sampledPrefix_eq (k : ℕ) (ω : UniformTapes ℕ) (i : Fin k) :
+    sampledPrefix f k ω i=sampledHistory f ω i := by
+  induction k with
+  | zero => exact Fin.elim0 i
+  | succ k ih =>
+    refine Fin.lastCases ?_ (fun j => ?_) i
+    · simp only [sampledPrefix_succ,Fin.snoc_last,Fin.val_last]
+    · simpa only [sampledPrefix_succ,Fin.snoc_castSucc,Fin.val_castSucc] using ih j
+
+lemma measurable_tape_coordinate (s : Set ℕ) (k : ℕ) (hk : k∈s) :
+    Measurable[tapeInformation s] (fun ω : UniformTapes ℕ => ω k) := by
+  rw [measurable_iff_comap_le]
+  exact le_iSup_of_le k (le_iSup_of_le hk le_rfl)
+lemma sampledPrefix_measurable (hf : ∀ k, Measurable (uncurry (f k))) (k : ℕ) :
+    Measurable[tapeInformation (Set.Iio k)] (sampledPrefix f k) := by
+  induction k with
+  | zero =>
+    let : MeasurableSpace (UniformTapes ℕ) := tapeInformation (Set.Iio 0)
+    apply Measurable.of_eval; intro i; exact Fin.elim0 i
+  | succ k ih =>
+    let : MeasurableSpace (UniformTapes ℕ) := tapeInformation (Set.Iio (k+1))
+    have hp : Measurable[tapeInformation (Set.Iio (k+1))] (sampledPrefix f k) :=
+      ih.mono (tapeInformation_mono (fun _ h => Nat.lt_trans h (Nat.lt_succ_self k))) le_rfl
+    have hu := measurable_tape_coordinate (Set.Iio (k+1)) k (Nat.lt_succ_self k)
+    apply Measurable.of_eval
+    intro i
+    refine Fin.lastCases ?_ (fun j => ?_) i
+    · simpa only [sampledPrefix_succ,sampledHistory,Fin.snoc_last,Function.comp_def,Function.uncurry] using (hf k).comp (hp.prodMk hu)
+    · simpa only [sampledPrefix_succ,Fin.snoc_castSucc,Function.comp_def] using (measurable_pi_apply j).comp hp
+lemma sampledPrefix_measurable_global (hf : ∀ k, Measurable (uncurry (f k))) (k : ℕ) :
+    Measurable (sampledPrefix f k) :=
+  (sampledPrefix_measurable f hf k).mono (tapeInformation_le _) le_rfl
+lemma sampledHistory_measurable (hf : ∀ k, Measurable (uncurry (f k))) :
+    Measurable (sampledHistory f) := by
+  apply Measurable.of_eval
+  intro k
+  exact (hf k).comp ((sampledPrefix_measurable_global f hf k).prodMk (measurable_pi_apply k))
+
+theorem sampled_history_step (hf : ∀ k, Measurable (uncurry (f k)))
+    (κ : (k : ℕ) → Kernel (Fin k → X) X) [∀ k, IsMarkovKernel (κ k)]
+    (hmap : ∀ k s, volume.map (f k s)=κ k s) (k : ℕ) :
+    uniformTapesLaw.map (fun ω => (sampledPrefix f k ω,sampledHistory f ω k))=
+      uniformTapesLaw.map (sampledPrefix f k) ⊗ₘ κ k := by
+  apply sampled_pair_law _ _ (sampledPrefix_measurable_global f hf k)
+    (measurable_pi_apply k) _ (tape_coordinate_law k) (κ k) (f k) (hf k) (hmap k)
+  exact fresh_coordinate_independent (by simp only [Set.mem_Iio]; exact lt_irrefl k) _
+    (sampledPrefix_measurable f hf k)
+
+end SecretKey
+
+namespace SecretKey
+open MeasureTheory ProbabilityTheory Function
+open scoped MeasureTheory ProbabilityTheory unitInterval
+variable {X : Type*} [MeasurableSpace X]
+def recordPrefix (k : ℕ) (x : ℕ → X) : Fin k → X := fun i => x i
+lemma recordPrefix_measurable (k : ℕ) : Measurable (recordPrefix (X := X) k) := by
+  apply Measurable.of_eval; intro i; exact measurable_pi_apply i.val
+lemma snoc_measurable (k : ℕ) :
+    Measurable (fun p : (Fin k → X)×X => Fin.snoc (α := fun _ : Fin (k+1) => X) p.1 p.2) := by
+  apply Measurable.of_eval
+  intro i
+  refine Fin.lastCases ?_ (fun j => ?_) i
+  · simpa only [Fin.snoc_last] using measurable_snd
+  · simpa only [Fin.snoc_castSucc,Function.comp_def] using (measurable_pi_apply j).comp measurable_fst
+omit [MeasurableSpace X] in
+lemma recordPrefix_succ (k : ℕ) (x : ℕ → X) :
+    recordPrefix (k+1) x=Fin.snoc (recordPrefix k x) (x k) := by
+  funext i
+  refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [recordPrefix]
+
+theorem full_history_law_unique (ν ξ : Measure (ℕ → X)) [IsFiniteMeasure ν]
+    (h : ∀ k, ν.map (recordPrefix k)=ξ.map (recordPrefix k)) : ν=ξ := by
+  let P := fun J : Finset ℕ => ν.map J.restrict
+  have hν : IsProjectiveLimit ν P := fun J => rfl
+  have hξ : IsProjectiveLimit ξ P := by
+    intro J
+    let k := J.sup id+1
+    have hb (i : J) : i.val<k := Nat.lt_succ_of_le (Finset.le_sup (f := id) i.property)
+    let g : (Fin k → X) → (J → X) := fun x i => x ⟨i.val,hb i⟩
+    have hg : Measurable g := by fun_prop
+    have he : J.restrict=(g ∘ recordPrefix k : (ℕ → X) → (J → X)) := rfl
+    change ξ.map J.restrict=ν.map J.restrict
+    rw [he,← Measure.map_map hg (recordPrefix_measurable k),
+      ← Measure.map_map hg (recordPrefix_measurable k),h k]
+  exact hν.unique hξ
+
+theorem sampled_full_history_law
+    (f : (k : ℕ) → (Fin k → X) → I → X)
+    (hf : ∀ k, Measurable (uncurry (f k)))
+    (κ : (k : ℕ) → Kernel (Fin k → X) X) [∀ k, IsMarkovKernel (κ k)]
+    (hmap : ∀ k s, volume.map (f k s)=κ k s)
+    (ν : Measure (ℕ → X)) [IsProbabilityMeasure ν]
+    (hν : ∀ k, ν.map (fun x => (recordPrefix k x,x k))=ν.map (recordPrefix k) ⊗ₘ κ k) :
+    ν=uniformTapesLaw.map (sampledHistory f) := by
+  have hp : ∀ k, ν.map (recordPrefix k)=uniformTapesLaw.map (sampledPrefix f k) := by
+    intro k
+    induction k with
+    | zero =>
+      have he : recordPrefix (X := X) 0=(fun _ : ℕ → X => (Fin.elim0 : Fin 0 → X)) := by
+        funext x i; exact Fin.elim0 i
+      have hf0 : sampledPrefix f 0=(fun _ : UniformTapes ℕ => (Fin.elim0 : Fin 0 → X)) := rfl
+      rw [he,hf0,Measure.map_const,Measure.map_const]
+      simp
+    | succ k ih =>
+      have he : recordPrefix (X := X) (k+1)=
+          (fun p : (Fin k → X)×X => Fin.snoc (α := fun _ : Fin (k+1) => X) p.1 p.2) ∘ (fun x => (recordPrefix k x,x k)) := by
+        funext x; exact recordPrefix_succ k x
+      have hx : Measurable (fun ω : UniformTapes ℕ => sampledHistory f ω k) := by
+        simpa only [Function.comp_def] using
+          (measurable_pi_apply k).comp (sampledHistory_measurable f hf)
+      rw [he,← Measure.map_map (snoc_measurable k)
+        ((recordPrefix_measurable k).prodMk (measurable_pi_apply k)),hν k,ih,
+        ← sampled_history_step f hf κ hmap k,Measure.map_map (snoc_measurable k)
+          ((sampledPrefix_measurable_global f hf k).prodMk hx)]
+      rfl
+  apply full_history_law_unique
+  intro k
+  rw [Measure.map_map (recordPrefix_measurable k) (sampledHistory_measurable f hf),hp k]
+  congr 1
+  funext ω i
+  exact sampledPrefix_eq f k ω i
+
+end SecretKey
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/SparseSeparable.lean

@@ -0,0 +1,129 @@
+import OAI.Analysis.Quantum.PPTSquare.ChannelModel
+import OAI.Analysis.Quantum.PPTSquare.Compression
+import OAI.Analysis.Quantum.PPTSquare.TensorModel
+import OAI.Analysis.Quantum.PPTSquare.TensorPositivity
+import OAI.Analysis.Quantum.PPTSquare.SymmetricVectors
+import OAI.Analysis.Quantum.PPTSquare.QuadraticCriterion
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder Kronecker
+open Matrix
+namespace ProjectionCriterion
+open ChannelCompletion TensorCriterion
+variable {n m r : Type} [Fintype n] [Fintype m] [Fintype r]
+
+omit [Fintype n] in
+lemma projector_col_sum (A : Matrix n m ℂ) :
+    (∑ j, projector (fun i => A i j)) = A*Aᴴ := by
+  ext i k
+  simp only [Matrix.sum_apply,projector,Matrix.vecMulVec_apply,Pi.star_apply,
+    Matrix.mul_apply,Matrix.conjTranspose_apply]
+
+lemma separable_rankone {C : Mat (n × m)} [DecidableEq n] [DecidableEq m]
+    (hC : Separable C) :
+    ∃ (t : ℕ) (x : Fin t × (n × m) → n → ℂ) (y : Fin t × (n × m) → m → ℂ),
+      C = ∑ k, projector (product (x k) (y k)) := by
+  obtain ⟨t,A,B,hA,hB,rfl⟩ := hC
+  let x : Fin t × (n × m) → n → ℂ := fun k i => CFC.sqrt (A k.1) i k.2.1
+  let y : Fin t × (n × m) → m → ℂ := fun k i => CFC.sqrt (B k.1) i k.2.2
+  refine ⟨t,x,y,?_⟩
+  rw [Fintype.sum_prod_type]
+  apply Finset.sum_congr rfl
+  intro k _
+  simp only [Fintype.sum_prod_type,x,y,projector_product]
+  have ha : (∑ j, projector (fun i => CFC.sqrt (A k) i j)) = A k :=
+    (projector_col_sum _).trans (sqrt_mul_conjTranspose _ (hA k))
+  have hb : (∑ j, projector (fun i => CFC.sqrt (B k) i j)) = B k :=
+    (projector_col_sum _).trans (sqrt_mul_conjTranspose _ (hB k))
+  calc
+    A k ⊗ₖ B k = (∑ j, projector (fun i => CFC.sqrt (A k) i j)) ⊗ₖ
+        (∑ j, projector (fun i => CFC.sqrt (B k) i j)) := by rw [ha,hb]
+    _ = _ := by
+      ext ⟨a,c⟩ ⟨b,d⟩
+      simp only [Matrix.kroneckerMap_apply,Matrix.sum_apply,Finset.sum_mul,Finset.mul_sum]
+      rw [Finset.sum_comm]
+
+omit [Fintype n] in
+lemma norm_sq_sum_le_card (s : Finset n) (z : n → ℂ) :
+    ‖∑ i ∈ s, z i‖^2 ≤ (s.card : ℝ) * ∑ i ∈ s, ‖z i‖^2 := by
+  have h := Finset.sum_mul_sq_le_sq_mul_sq s (fun _ => (1 : ℝ)) (fun i => ‖z i‖)
+  simp only [one_mul,one_pow,Finset.sum_const,mul_one,nsmul_eq_mul] at h
+  have hn := norm_sum_le s z
+  have hx : 0 ≤ ∑ i ∈ s, ‖z i‖ := Finset.sum_nonneg (fun _ _ => norm_nonneg _)
+  nlinarith [norm_nonneg (∑ i ∈ s, z i)]
+
+lemma norm_sq_sparse_sum [DecidableEq n] (z : n → ℂ) (κ : ℝ)
+    (h : ((Finset.univ.filter (fun i => z i ≠ 0)).card : ℝ) ≤ κ) :
+    ‖∑ i, z i‖^2 ≤ κ * ∑ i, ‖z i‖^2 := by
+  let S := Finset.univ.filter (fun i => z i ≠ 0)
+  have hsum : ∑ i ∈ S, z i = ∑ i, z i := by
+    apply Finset.sum_subset (Finset.filter_subset _ _)
+    intro i _ hi
+    simpa [S] using hi
+  have hsq : ∑ i ∈ S, ‖z i‖^2 = ∑ i, ‖z i‖^2 := by
+    apply Finset.sum_subset (Finset.filter_subset _ _)
+    intro i _ hi
+    have hz : z i=0 := by simpa [S] using hi
+    simp [hz]
+  have hc := norm_sq_sum_le_card S z
+  rw [hsum,hsq] at hc
+  exact hc.trans (mul_le_mul_of_nonneg_right h (Finset.sum_nonneg (fun i _ => sq_nonneg _)))
+
+lemma mul_star_re (z : ℂ) : (z * star z).re = ‖z‖^2 := by
+  rw [Complex.star_def,Complex.mul_conj,Complex.ofReal_re,Complex.normSq_eq_norm_sq]
+
+omit [Fintype n] in
+lemma projector_diagonal (z : n → ℂ) (i : n) : (projector z i i).re = ‖z i‖^2 :=
+  mul_star_re _
+lemma projector_all_sum (z : n → ℂ) :
+    (∑ i, ∑ j, projector z i j).re = ‖∑ i, z i‖^2 := by
+  simp only [projector,Matrix.vecMulVec_apply,Pi.star_apply]
+  simp_rw [← Finset.mul_sum]
+  rw [← Finset.sum_mul,← star_sum]
+  exact mul_star_re _
+
+def compressionSum (C : Mat (n × n)) : ℝ := (∑ i, ∑ j, C (i,i) (j,j)).re
+def compressionTrace (C : Mat (n × n)) : ℝ := (∑ i, C (i,i) (i,i)).re
+
+theorem separable_compression_bound [DecidableEq n] {C : Mat (n × n)}
+    (hC : Separable C) (κ : ℝ)
+    (hclique : ∀ J : Finset n,
+      (∀ i ∈ J, ∀ j ∈ J, i ≠ j → 0 < (C (i,j) (i,j)).re) → (J.card : ℝ) ≤ κ) :
+    compressionSum C ≤ κ * compressionTrace C := by
+  obtain ⟨t,x,y,hC⟩ := separable_rankone hC
+  let z := fun k i => x k i * y k i
+  have hd (i j : n) : (C (i,j) (i,j)).re = ∑ k, ‖x k i * y k j‖^2 := by
+    rw [hC]
+    simp only [Matrix.sum_apply,Complex.re_sum,projector_diagonal,product]
+  have hsupport (k : Fin t × (n × n)) :
+      ((Finset.univ.filter (fun i => z k i ≠ 0)).card : ℝ) ≤ κ := by
+    apply hclique
+    intro i hi j hj _
+    have hi' : x k i ≠ 0 := (mul_ne_zero_iff.mp (Finset.mem_filter.mp hi).2).1
+    have hj' : y k j ≠ 0 := (mul_ne_zero_iff.mp (Finset.mem_filter.mp hj).2).2
+    rw [hd]
+    have hle : ‖x k i*y k j‖^2 ≤ ∑ k', ‖x k' i*y k' j‖^2 :=
+      Finset.single_le_sum (fun k' _ => sq_nonneg ‖x k' i*y k' j‖) (Finset.mem_univ k)
+    exact (sq_pos_of_pos (norm_pos_iff.mpr (mul_ne_zero hi' hj'))).trans_le hle
+  have hs : compressionSum C = ∑ k, ‖∑ i, z k i‖^2 := by
+    rw [hC]
+    simp only [compressionSum,Matrix.sum_apply,Complex.re_sum]
+    conv_lhs => arg 2; ext i; rw [Finset.sum_comm]
+    rw [Finset.sum_comm]
+    apply Finset.sum_congr rfl
+    intro k _
+    have he (i j : n) : projector (product (x k) (y k)) (i,i) (j,j) = projector (z k) i j := rfl
+    simp only [he,← Complex.re_sum,projector_all_sum]
+  have ht : compressionTrace C = ∑ k, ∑ i, ‖z k i‖^2 := by
+    rw [hC]
+    simp only [compressionTrace,Matrix.sum_apply,Complex.re_sum,projector_diagonal,product,z]
+    rw [Finset.sum_comm]
+  rw [hs,ht,Finset.mul_sum]
+  exact Finset.sum_le_sum (fun k _ => norm_sq_sparse_sum (z k) κ (hsupport k))
+end ProjectionCriterion
+
+end
+
+end OAI

lean/OAI/InformationTheory/Entanglement/SpectralCut.lean

@@ -0,0 +1,139 @@
+import OAI.InformationTheory.Entanglement.EffectNormalization
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators ComplexOrder MatrixOrder
+open Matrix
+namespace SecretKey
+variable {n : Type} [Fintype n] [DecidableEq n]
+
+lemma unitary_conjugate_mul {U : Matrix n n ℂ} (hU : Uᴴ*U=1) (A B : Matrix n n ℂ) :
+    (Uᴴ*A*U)*(Uᴴ*B*U)=Uᴴ*(A*B)*U := by
+  have hU' := unitary_reverse hU
+  simp only [Matrix.mul_assoc]
+  rw [← Matrix.mul_assoc U Uᴴ, hU',Matrix.one_mul]
+
+lemma unitary_conjugate_cancel {U : Matrix n n ℂ} (hU : Uᴴ*U=1) (A : Matrix n n ℂ) :
+    U*(Uᴴ*A*U)*Uᴴ=A := by
+  calc
+    U*(Uᴴ*A*U)*Uᴴ=(U*Uᴴ)*A*(U*Uᴴ) := by simp only [Matrix.mul_assoc]
+    _ = A := by rw [unitary_reverse hU,Matrix.one_mul,Matrix.mul_one]
+
+lemma unitary_conjugate_restore {U : Matrix n n ℂ} (hU : Uᴴ*U=1) (A : Matrix n n ℂ) :
+    Uᴴ*(U*A*Uᴴ)*U=A := by
+  calc
+    Uᴴ*(U*A*Uᴴ)*U=(Uᴴ*U)*A*(Uᴴ*U) := by simp only [Matrix.mul_assoc]
+    _ = A := by rw [hU,Matrix.one_mul,Matrix.mul_one]
+
+lemma spectral_cut {A B : Matrix n n ℂ} (hA : A.IsHermitian) (hB : B.IsHermitian)
+    (hAB : Commute A B) :
+    ∃ P : Matrix n n ℂ, Pᴴ=P ∧ P*P=P ∧ Commute P A ∧ Commute P B ∧
+      (P*(A-B)*P).PosSemidef ∧ ((1-P)*(B-A)*(1-P)).PosSemidef := by
+  let C := A-B
+  have hC : C.IsHermitian := hA.sub hB
+  obtain ⟨U,hU,hdiag⟩ := unitary_spectral hC
+  have hU' := unitary_reverse hU
+  let eig := hC.eigenvalues
+  let a := Uᴴ*A*U
+  let b := Uᴴ*B*U
+  let D : Matrix n n ℂ := diagonal (fun i => (eig i : ℂ))
+  change Uᴴ*C*U=D at hdiag
+  have hab : a-b=D := by
+    rw [← hdiag]
+    simp [a,b,C,Matrix.mul_sub,Matrix.sub_mul]
+  have hCA : C*A=A*C := by
+    dsimp [C]
+    rw [Matrix.sub_mul,Matrix.mul_sub,hAB.eq]
+  have hDa : D*a=a*D := by
+    rw [← hab]
+    change (Uᴴ*A*U-Uᴴ*B*U)*(Uᴴ*A*U)=(Uᴴ*A*U)*(Uᴴ*A*U-Uᴴ*B*U)
+    rw [← Matrix.sub_mul,← Matrix.mul_sub]
+    rw [unitary_conjugate_mul hU,unitary_conjugate_mul hU,hCA]
+  let q : n → ℂ := fun i => if 0 ≤ eig i then 1 else 0
+  let Q : Matrix n n ℂ := diagonal q
+  have hQ : Qᴴ=Q := by simp [Q,q,Matrix.diagonal_conjTranspose]
+  have hQQ : Q*Q=Q := by
+    rw [Matrix.diagonal_mul_diagonal]
+    congr 1
+    funext i
+    simp [q]
+  have hezero (i j : n) (hne : (0 ≤ eig i) ≠ (0 ≤ eig j)) : a i j=0 := by
+    have he := congrArg (fun M => M i j) hDa
+    simp only [D,Matrix.diagonal_mul,Matrix.mul_diagonal] at he
+    have hz : ((eig i : ℂ) - eig j)*a i j=0 := by linear_combination he
+    apply (mul_eq_zero.mp hz).resolve_left
+    intro hij
+    apply hne
+    have hh : eig i=eig j := Complex.ofReal_injective (sub_eq_zero.mp hij)
+    rw [hh]
+  have hQa : Q*a=a*Q := by
+    ext i j
+    simp only [Q,Matrix.diagonal_mul,Matrix.mul_diagonal,q]
+    split_ifs with hi hj hj
+    · simp
+    · rw [hezero i j (by simp [hi,hj])]; simp
+    · rw [hezero i j (by simp [hi,hj])]; simp
+    · simp
+  have hQb : Q*b=b*Q := by
+    have hb : b=a-D := by rw [← hab]; abel
+    rw [hb,Matrix.mul_sub,Matrix.sub_mul,hQa]
+    congr 1
+    simp [Q,D,Matrix.diagonal_mul_diagonal,mul_comm]
+  let P := U*Q*Uᴴ
+  have hP : Pᴴ=P := by simp [P,Matrix.conjTranspose_mul,hQ,Matrix.mul_assoc]
+  have hP' : Uᴴ*P*U=Q := by
+    dsimp [P]
+    simp only [← Matrix.mul_assoc,hU,Matrix.one_mul]
+    rw [Matrix.mul_assoc,hU,Matrix.mul_one]
+  have hstrong (E F : Matrix n n ℂ) (he : Uᴴ*E*U=Uᴴ*F*U) : E=F := by
+    have hh := congrArg (fun M => U*M*Uᴴ) he
+    simpa only [unitary_conjugate_cancel hU] using hh
+  have hPP : P*P=P := by
+    apply hstrong
+    rw [← unitary_conjugate_mul hU P P,hP',hQQ]
+  have hPA : Commute P A := by
+    change P*A=A*P
+    apply hstrong
+    rw [← unitary_conjugate_mul hU P A,← unitary_conjugate_mul hU A P,hP']
+    exact hQa
+  have hPB : Commute P B := by
+    change P*B=B*P
+    apply hstrong
+    rw [← unitary_conjugate_mul hU P B,← unitary_conjugate_mul hU B P,hP']
+    exact hQb
+  have hRe : Uᴴ*(1-P)*U=1-Q := by
+    rw [Matrix.mul_sub,Matrix.sub_mul,Matrix.mul_one,hU,hP']
+  have hpos : (Q*D*Q).PosSemidef := by
+    simp only [Q,D,Matrix.diagonal_mul_diagonal]
+    apply Matrix.PosSemidef.diagonal
+    intro i
+    dsimp [q]
+    split_ifs with hi
+    · simpa using (show (0:ℂ) ≤ eig i from Complex.nonneg_iff.mpr ⟨hi,by simp⟩)
+    · simp
+  have hneg : ((1-Q)*(-D)*(1-Q)).PosSemidef := by
+    have h1 : (1 : Matrix n n ℂ)=diagonal (fun _ => 1) := Matrix.diagonal_one.symm
+    simp only [h1,Q,D,Matrix.diagonal_sub,Matrix.diagonal_neg,
+      Matrix.diagonal_mul_diagonal,Matrix.diagonal_mul_diagonal]
+    apply Matrix.PosSemidef.diagonal
+    intro i
+    dsimp [q]
+    split_ifs with hi
+    · simp
+    · simpa using (show (0:ℂ) ≤ -(eig i:ℂ) from Complex.nonneg_iff.mpr ⟨by simpa using le_of_lt (neg_pos.mpr (lt_of_not_ge hi)),by simp⟩)
+  refine ⟨P,hP,hPP,hPA,hPB,?_,?_⟩
+  · have hh := hpos.mul_mul_conjTranspose_same U
+    convert hh using 1
+    apply hstrong
+    rw [← unitary_conjugate_mul hU (P*C) P,← unitary_conjugate_mul hU P C,hP',hdiag,unitary_conjugate_restore hU]
+  · have hh := hneg.mul_mul_conjTranspose_same U
+    convert hh using 1
+    apply hstrong
+    have hd : Uᴴ*(B-A)*U = -D := by rw [show B-A= -C from by dsimp [C]; abel, Matrix.mul_neg,Matrix.neg_mul,hdiag]
+    rw [← unitary_conjugate_mul hU ((1-P)*(B-A)) (1-P),← unitary_conjugate_mul hU (1-P) (B-A),hRe,hd,unitary_conjugate_restore hU]
+end SecretKey
+
+end
+
+end OAI