| import OAI.InformationTheory.SecretKey.Gap |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace ZeroKey |
|
|
| section |
|
|
| open Matrix |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
|
|
| universe v10089_0 v10089_1 |
|
|
| variable {ι : Type v10089_0} {κ : Type v10089_1} [inst10089_0 : Fintype ι] [inst10089_1 : Fintype κ] [inst10089_2 : DecidableEq ι] [inst10089_3 : DecidableEq κ] |
|
|
| lemma purification_filter_identity [Nonempty ι] (P : Matrix ι κ ℂ) : |
| referenceFilter (purificationFilter P) (outer (localProbe (ι := ι)) localProbe) = |
| outer (vectorize P) (vectorize P) := by |
| unfold localProbe purificationFilter |
| rw [referenceFilter_vectorize,Matrix.transpose_smul,Matrix.transpose_transpose, |
| Matrix.smul_mul,Matrix.mul_smul,Matrix.one_mul,smul_smul] |
| have hc : (Real.sqrt (Fintype.card ι : ℝ) : ℂ) ≠ 0 := |
| Complex.ofReal_ne_zero.mpr (Real.sqrt_pos.mpr (by exact_mod_cast Fintype.card_pos)).ne' |
| rw [inv_mul_cancel₀ hc,one_smul] |
|
|
| end |
|
|
| section |
|
|
| open Matrix MeasureTheory |
|
|
| open scoped ComplexOrder MatrixOrder Kronecker Matrix.Norms.L2Operator |
|
|
| universe v10152_0 v10152_1 v10152_2 |
|
|
| variable {ι : Type v10152_0} {κ : Type v10152_1} {Ω : Type v10152_2} [inst10152_0 : Fintype ι] [inst10152_1 : Fintype κ] [inst10152_2 : DecidableEq ι] [inst10152_3 : DecidableEq κ] |
| [inst10152_4 : MeasurableSpace Ω] {μ : Measure Ω} |
|
|
| def BitDensity.mapReference (τ : BitDensity μ κ) |
| (L : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ) |
| (hpos : ∀ Z, Z.PosSemidef → (L Z).PosSemidef) |
| (htr : ∀ Z, trace (L Z) = trace Z) : BitDensity μ ι where |
| block i j t := L (τ.block i j t) |
| positive i j t := hpos _ (τ.positive i j t) |
| measurable i j := L.continuous_of_finiteDimensional.measurable.comp (τ.measurable i j) |
| integrable i j := by simpa only [htr] using τ.integrable i j |
| normalized := by simpa only [htr] using τ.normalized |
|
|
| lemma traceNorm_channel_sub (L : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ) |
| (hpos : ∀ Z, Z.PosSemidef → (L Z).PosSemidef) |
| (htr : ∀ Z, trace (L Z) = trace Z) |
| {A B : Matrix κ κ ℂ} (hA : A.PosSemidef) (hB : B.PosSemidef) : |
| traceNorm (L A - L B) ≤ traceNorm (A-B) := by |
| rw [← map_sub] |
| exact traceNorm_positive_tracePreserving L hpos htr _ (hA.isHermitian.sub hB.isHermitian) |
|
|
| theorem BitDensity.idealBitError_mapReference_le (τ : BitDensity μ κ) |
| (L : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ) |
| (hpos : ∀ Z, Z.PosSemidef → (L Z).PosSemidef) |
| (htr : ∀ Z, trace (L Z) = trace Z) |
| (σ : Ω → Matrix κ κ ℂ) (hσ : Measurable σ) |
| (hσp : ∀ t, (σ t).PosSemidef) |
| (hσi : Integrable (fun t => (trace (σ t)).re) μ) : |
| (τ.mapReference L hpos htr).idealBitError (fun t => L (σ t)) ≤ τ.idealBitError σ := by |
| have hm : Measurable (fun t => L (σ t)) := L.continuous_of_finiteDimensional.measurable.comp hσ |
| have hi : Integrable (fun t => (trace (L (σ t))).re) μ := by simpa only [htr] using hσi |
| have hc (a : Bool) : |
| (∫ t, traceNorm (L (τ.block a a t) - (1/2 : ℝ) • L (σ t)) ∂μ) ≤ |
| ∫ t, traceNorm (τ.block a a t - (1/2 : ℝ) • σ t) ∂μ := by |
| have hleft := traceNorm_sub_integrable |
| (L.continuous_of_finiteDimensional.measurable.comp (τ.measurable a a)) |
| (show Measurable (fun t => (1/2 : ℝ) • L (σ t)) from hm.const_smul (1/2 : ℝ)) (fun t => hpos _ (τ.positive a a t)) |
| (fun t => (hpos _ (hσp t)).smul (show (0:ℝ)≤1/2 by norm_num)) |
| (show Integrable (fun t => (trace (L (τ.block a a t))).re) μ by simpa only [htr] using τ.integrable a a) |
| (by simpa only [Matrix.trace_smul,Complex.smul_re,smul_eq_mul] using hi.const_mul (1/2)) |
| have hright := traceNorm_sub_integrable (τ.measurable a a) (show Measurable (fun t => (1/2 : ℝ) • σ t) from hσ.const_smul (1/2 : ℝ)) |
| (τ.positive a a) (fun t => (hσp t).smul (show (0:ℝ)≤1/2 by norm_num)) |
| (τ.integrable a a) |
| (by simpa only [Matrix.trace_smul,Complex.smul_re,smul_eq_mul] using hσi.const_mul (1/2)) |
| apply integral_mono hleft hright |
| intro t |
| change traceNorm (L (τ.block a a t) - (1/2 : ℝ) • L (σ t)) ≤ _ |
| rw [← L.map_smul_of_tower (1/2 : ℝ) (σ t)] |
| exact traceNorm_channel_sub L hpos htr (τ.positive a a t) |
| ((hσp t).smul (show (0:ℝ)≤1/2 by norm_num)) |
| have hf := hc false |
| have ht := hc true |
| unfold BitDensity.idealBitError BitDensity.mass |
| simp only [BitDensity.mapReference,htr] |
| linarith |
|
|
| end |
|
|
| open Matrix MeasureTheory ProbabilityTheory Function Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
|
|
| open UnrestrictedQuantum |
|
|
| universe v10227_0 v10227_1 v10227_2 v10227_3 v10227_4 v10227_5 v10227_6 v10227_7 v10227_8 v10227_9 v10227_10 |
|
|
| variable {O : Type v10227_0} {M : Type v10227_1} {ι : Type v10227_2} {η : Type v10227_3} [inst10227_0 : MeasurableSpace O] [inst10227_1 : MeasurableSpace M] |
| [inst10227_2 : StandardBorelSpace O] [inst10227_3 : Nonempty O] [inst10227_4 : StandardBorelSpace M] [inst10227_5 : Nonempty M] |
| [inst10227_6 : Fintype ι] [inst10227_7 : Fintype η] [inst10227_8 : DecidableEq ι] [inst10227_9 : DecidableEq η] |
| [inst10227_10 : Nonempty ι] [inst10227_11 : Nonempty η] |
| {d : Discussion O M} {A : ℕ → Type v10227_4} {B : ℕ → Type v10227_5} |
| [inst10227_12 : ∀ n, AddCommGroup (A n)] [inst10227_13 : ∀ n, Module ℂ (A n)] [inst10227_14 : ∀ n, One (A n)] [inst10227_15 : ∀ n, LE (A n)] |
| [inst10227_16 : ∀ n, AddCommGroup (B n)] [inst10227_17 : ∀ n, Module ℂ (B n)] [inst10227_18 : ∀ n, One (B n)] [inst10227_19 : ∀ n, LE (B n)] |
| {TA : Type v10227_6} {TB : Type v10227_7} {CA : Type v10227_8} {CB : Type v10227_9} |
| [inst10227_20 : AddCommGroup TA] [inst10227_21 : Module ℂ TA] [inst10227_22 : One TA] [inst10227_23 : LE TA] |
| [inst10227_24 : AddCommGroup TB] [inst10227_25 : Module ℂ TB] [inst10227_26 : One TB] [inst10227_27 : LE TB] |
| [inst10227_28 : AddCommGroup CA] [inst10227_29 : Module ℂ CA] [inst10227_30 : One CA] [inst10227_31 : LE CA] |
| [inst10227_32 : AddCommGroup CB] [inst10227_33 : Module ℂ CB] [inst10227_34 : One CB] [inst10227_35 : LE CB] |
| {κ : Type v10227_10} [inst10227_36 : Fintype κ] [inst10227_37 : DecidableEq κ] |
|
|
| namespace BitProtocol |
|
|
| variable (p : BitProtocol (ι := ι) (η := η) d A B TA TB CA CB) |
| (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (P : Matrix (ι × η) κ ℂ) (hP : P * Pᴴ = R) |
|
|
| include hR hP |
|
|
| lemma purifiedDensity_recovery (ν : Measure (ℕ → M)) [SigmaFinite ν] |
| (hμν : d.transcriptLaw ≪ ν) |
| (L : Matrix κ κ ℂ →ₗ[ℂ] Matrix (ι × η) (ι × η) ℂ) |
| (he : ∀ i j S, L ((p.purifiedOutput P i j).value S) = (p.canonicalOutput R i j).value S) |
| (i j : Bool) : |
| (p.outputDensity R hR ν hμν).block i j =ᵐ[ν] |
| fun t => L ((p.purifiedDensity R hR P hP ν hμν).block i j t) := by |
| have hAC (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| (p.purifiedOutput P i j).value S = 0 := p.purifiedOutput_ac P i j S hS (hμν hz) |
| let LC := L.toContinuousLinearMap |
| apply (p.canonicalOutput R i j).positiveDensity_eq_ae ν |
| (LC.integrable_comp ((p.purifiedOutput P i j).positiveDensity_integrable ν hAC)) |
| intro S hS |
| rw [LC.integral_comp_comm ((p.purifiedOutput P i j).positiveDensity_integrable ν hAC).integrableOn, |
| (p.purifiedOutput P i j).positiveDensity_integral ν hAC S hS] |
| exact (he i j S).symm |
|
|
| end BitProtocol |
|
|
| theorem BitProtocol.uniform_gap_purification {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (p : BitProtocol (ι := Fin a) (η := Fin b) d A B TA TB CA CB) |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : InClass R) |
| (P : Matrix (Fin a × Fin b) κ ℂ) (hP : P * Pᴴ = R) |
| (sigma : PositiveMatrixMeasure (ℕ → M) κ) |
| (hsigma : (trace (sigma.value Set.univ)).re = 1) : |
| 1/5 ≤ p.purifiedSecretBitError R hR.1 P hP sigma := by |
| let ν := d.transcriptLaw + sigma.traceMeasure |
| have hμν : d.transcriptLaw ≪ ν := Measure.AbsolutelyContinuous.rfl.add_right _ |
| have hsν : sigma.traceMeasure ≪ ν := Measure.AbsolutelyContinuous.rfl.add_right' _ |
| have hsAC (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| sigma.value S = 0 := sigma.value_zero_of_traceMeasure_zero S hS (hsν hz) |
| obtain ⟨L,hpos,htr,hrec⟩ := p.purifiedOutput_recovery R hR.1 P hP |
| let tp := p.purifiedDensity R hR.1 P hP ν hμν |
| let tc := p.outputDensity R hR.1 ν hμν |
| let sp := sigma.positiveDensity ν |
| have hspm := sigma.measurable_positiveDensity ν |
| have hspp := sigma.positiveDensity_pos ν |
| have hspi := sigma.integrable_positiveDensity_trace ν hsAC |
| have hspn := (sigma.integral_positiveDensity_trace ν hsAC).trans hsigma |
| obtain ⟨τ,X,Y,hX,hY,hτ,hi,he⟩ := p.canonical_density_representation R hR.1 |
| have hg := class_factor_gap_dominating_measure hμν R hR τ X Y hX hY hτ |
| (fun t => L (sp t)) (L.continuous_of_finiteDimensional.measurable.comp hspm) |
| (fun t => hpos _ (hspp t)) |
| (show Integrable (fun t => (trace (L (sp t))).re) ν by simpa only [htr] using hspi) |
| (show (∫ t, (trace (L (sp t))).re ∂ν) = 1 by simpa only [htr] using hspn) |
| have heq := BitDensity.idealBitError_congr tc (τ.changeMeasure hμν) |
| (fun t => L (sp t)) (fun t => L (sp t)) |
| (p.outputDensity_eq R hR.1 ν hμν τ hi he) Filter.EventuallyEq.rfl |
| have hrc := BitDensity.idealBitError_congr tc (tp.mapReference L hpos htr) |
| (fun t => L (sp t)) (fun t => L (sp t)) |
| (p.purifiedDensity_recovery R hR.1 P hP ν hμν L hrec) Filter.EventuallyEq.rfl |
| have hcontract := tp.idealBitError_mapReference_le L hpos htr sp hspm hspp hspi |
| change 1/5 ≤ tp.idealBitError sp |
| rw [← heq,hrc] at hg |
| exact hg.trans hcontract |
|
|
| end ZeroKey |
|
|
| namespace UnrestrictedQuantum |
|
|
| open Matrix MeasureTheory Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
|
|
| universe v10518_0 v10518_1 v10518_2 v10518_3 v10518_4 |
|
|
| variable {A : Type v10518_0} {B : Type v10518_1} {K : Type v10518_2} {ι : Type v10518_3} {Ω : Type v10518_4} [inst10518_0 : AddCommGroup A] [inst10518_1 : Module ℂ A] [inst10518_2 : One A] [inst10518_3 : LE A] |
| [inst10518_4 : AddCommGroup B] [inst10518_5 : Module ℂ B] [inst10518_6 : One B] [inst10518_7 : LE B] |
| [inst10518_8 : MeasurableSpace K] [inst10518_9 : MeasurableSingletonClass K] [inst10518_10 : Fintype K] [inst10518_11 : DecidableEq K] [inst10518_12 : Nonempty K] |
| [inst10518_13 : Fintype ι] [inst10518_14 : DecidableEq ι] |
|
|
| variable {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| {μ : Measure Ω} {F : Filtration ℕ mΩ} {U : ℕ → Ω → Matrix ι ι ℂ} |
| (e : IncomingObservableProcess (L := L) (A := A) μ F U) |
|
|
| namespace IncomingObservableProcess |
|
|
| namespace FiniteReadout |
|
|
| variable {e} (b : e.FiniteReadout (B := B) (K := K)) |
|
|
| lemma postprocess_value (f : K → Bool) (i : Bool) (x : Ω) : |
| (b.postprocess f).value i x = ∑ k ∈ Finset.univ.filter (fun k => f k = i), b.value k x := by |
| have hs : ((Finset.univ.filter (fun k => f k = i) : Finset K) : Set K) = f ⁻¹' {i} := by |
| ext k; simp |
| change e.state x ((b.instrument x).operation (f ⁻¹' {i}) 1) = _ |
| rw [← hs] |
| exact b.event_finset _ x |
|
|
| end FiniteReadout |
|
|
| end IncomingObservableProcess |
|
|
| end UnrestrictedQuantum |
|
|
| namespace ZeroKey |
|
|
| section |
|
|
| open Matrix MeasureTheory ProbabilityTheory Function unitInterval Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
|
|
| section |
|
|
| open UnrestrictedQuantum |
|
|
| universe v10619_0 v10619_1 v10619_2 v10619_3 v10619_4 v10619_5 v10619_6 v10619_7 v10619_8 v10619_9 v10619_10 |
|
|
| variable {O : Type v10619_0} {M : Type v10619_1} {ι : Type v10619_2} {η : Type v10619_3} [inst10619_0 : MeasurableSpace O] [inst10619_1 : MeasurableSpace M] |
| [inst10619_2 : StandardBorelSpace O] [inst10619_3 : Nonempty O] [inst10619_4 : StandardBorelSpace M] [inst10619_5 : Nonempty M] |
| [inst10619_6 : Fintype ι] [inst10619_7 : Fintype η] [inst10619_8 : DecidableEq ι] [inst10619_9 : DecidableEq η] |
| {K : Type v10619_4} [inst10619_10 : MeasurableSpace K] [inst10619_11 : MeasurableSingletonClass K] |
| [inst10619_12 : Fintype K] [inst10619_13 : DecidableEq K] [inst10619_14 : Nonempty K] |
| (d : Discussion O M) |
| (A : ℕ → Type v10619_5) (B : ℕ → Type v10619_6) |
| [inst10619_15 : ∀ n, AddCommGroup (A n)] [inst10619_16 : ∀ n, Module ℂ (A n)] [inst10619_17 : ∀ n, One (A n)] [inst10619_18 : ∀ n, LE (A n)] |
| [inst10619_19 : ∀ n, AddCommGroup (B n)] [inst10619_20 : ∀ n, Module ℂ (B n)] [inst10619_21 : ∀ n, One (B n)] [inst10619_22 : ∀ n, LE (B n)] |
| (TA : Type v10619_7) (TB : Type v10619_8) (CA : Type v10619_9) (CB : Type v10619_10) |
| [inst10619_23 : AddCommGroup TA] [inst10619_24 : Module ℂ TA] [inst10619_25 : One TA] [inst10619_26 : LE TA] |
| [inst10619_27 : AddCommGroup TB] [inst10619_28 : Module ℂ TB] [inst10619_29 : One TB] [inst10619_30 : LE TB] |
| [inst10619_31 : AddCommGroup CA] [inst10619_32 : Module ℂ CA] [inst10619_33 : One CA] [inst10619_34 : LE CA] |
| [inst10619_35 : AddCommGroup CB] [inst10619_36 : Module ℂ CB] [inst10619_37 : One CB] [inst10619_38 : LE CB] |
|
|
| variable {d A B TA TB CA CB} |
|
|
| namespace FiniteProtocol |
|
|
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := K) d A B TA TB CA CB) |
|
|
| lemma canonicalOutput_ac (R : Matrix (ι × η) (ι × η) ℂ) (i j : K) |
| (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : d.transcriptLaw S = 0) : |
| (p.canonicalOutput R i j).value S = 0 := by |
| have hp : d.probeLaw (d.sampler.publicRecord ⁻¹' S) = 0 := by |
| simpa only [Discussion.transcriptLaw,Measure.map_apply d.sampler.measurable_publicRecord hS] using hz |
| rw [p.canonicalOutput_event R i j S hS,Measure.restrict_eq_zero.mpr hp,integral_zero_measure] |
|
|
| def outputDensity (R : Matrix (ι × η) (ι × η) ℂ) (ν : Measure (ℕ → M)) (i j : K) : |
| (ℕ → M) → Matrix (ι × η) (ι × η) ℂ := (p.canonicalOutput R i j).positiveDensity ν |
|
|
| end FiniteProtocol |
|
|
| end |
|
|
| section |
|
|
| open UnrestrictedQuantum |
|
|
| universe v10740_0 v10740_1 v10740_2 v10740_3 v10740_4 v10740_5 v10740_6 v10740_7 v10740_8 v10740_9 v10740_10 |
|
|
| variable {O : Type v10740_0} {M : Type v10740_1} {ι : Type v10740_2} {η : Type v10740_3} [inst10740_0 : MeasurableSpace O] [inst10740_1 : MeasurableSpace M] |
| [inst10740_2 : StandardBorelSpace O] [inst10740_3 : Nonempty O] [inst10740_4 : StandardBorelSpace M] [inst10740_5 : Nonempty M] |
| [inst10740_6 : Fintype ι] [inst10740_7 : Fintype η] [inst10740_8 : DecidableEq ι] [inst10740_9 : DecidableEq η] [inst10740_10 : Nonempty ι] [inst10740_11 : Nonempty η] |
| {Λ : Type v10740_4} [inst10740_12 : MeasurableSpace Λ] [inst10740_13 : MeasurableSingletonClass Λ] |
| [inst10740_14 : Fintype Λ] [inst10740_15 : DecidableEq Λ] [inst10740_16 : Nonempty Λ] |
| (d : Discussion O M) |
| (A : ℕ → Type v10740_5) (B : ℕ → Type v10740_6) |
| [inst10740_17 : ∀ n, AddCommGroup (A n)] [inst10740_18 : ∀ n, Module ℂ (A n)] [inst10740_19 : ∀ n, One (A n)] [inst10740_20 : ∀ n, LE (A n)] |
| [inst10740_21 : ∀ n, AddCommGroup (B n)] [inst10740_22 : ∀ n, Module ℂ (B n)] [inst10740_23 : ∀ n, One (B n)] [inst10740_24 : ∀ n, LE (B n)] |
| (TA : Type v10740_7) (TB : Type v10740_8) (CA : Type v10740_9) (CB : Type v10740_10) |
| [inst10740_25 : AddCommGroup TA] [inst10740_26 : Module ℂ TA] [inst10740_27 : One TA] [inst10740_28 : LE TA] |
| [inst10740_29 : AddCommGroup TB] [inst10740_30 : Module ℂ TB] [inst10740_31 : One TB] [inst10740_32 : LE TB] |
| [inst10740_33 : AddCommGroup CA] [inst10740_34 : Module ℂ CA] [inst10740_35 : One CA] [inst10740_36 : LE CA] |
| [inst10740_37 : AddCommGroup CB] [inst10740_38 : Module ℂ CB] [inst10740_39 : One CB] [inst10740_40 : LE CB] |
|
|
| variable {d A B TA TB CA CB} |
|
|
| namespace FiniteProtocol |
|
|
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := Bool × Λ) d A B TA TB CA CB) |
|
|
| def firstBit : BitProtocol (ι := ι) (η := η) d A B TA TB CA CB := p.toBit Prod.fst |
|
|
| omit inst10740_4 inst10740_5 inst10740_10 inst10740_11 in |
| lemma firstBit_completeReference [StandardBorelSpace M] [Nonempty M] [Nonempty ι] [Nonempty η] (i j : Bool) (x : ℕ → O) : |
| p.firstBit.completeReference i j x = |
| ∑ a : Λ, ∑ b : Λ, p.completeReference (i,a) (j,b) x := by |
| have ha : (p.readoutA.postprocess Prod.fst).value i x = ∑ a : Λ, p.readoutA.value (i,a) x := by |
| rw [IncomingObservableProcess.FiniteReadout.postprocess_value] |
| cases i <;> simp [Finset.sum_filter,Fintype.sum_prod_type] |
| have hb : (p.readoutB.postprocess Prod.fst).value j x = ∑ b : Λ, p.readoutB.value (j,b) x := by |
| rw [IncomingObservableProcess.FiniteReadout.postprocess_value] |
| cases j <;> simp [Finset.sum_filter,Fintype.sum_prod_type] |
| change (p.readoutA.postprocess Prod.fst).value i x ⊗ₖ |
| (p.readoutB.postprocess Prod.fst).value j x = _ |
| rw [ha,hb] |
| ext k l |
| simp only [Matrix.kroneckerMap_apply,Matrix.sum_apply,Finset.sum_mul,Finset.mul_sum,completeReference,Matrix.kroneckerMap_apply] |
| rw [Finset.sum_comm] |
|
|
| lemma firstBit_output_event (R : Matrix (ι × η) (ι × η) ℂ) |
| (i j : Bool) (S : Set (ℕ → M)) (hS : MeasurableSet S) : |
| (p.firstBit.canonicalOutput R i j).value S = |
| ∑ a : Λ, ∑ b : Λ, (p.canonicalOutput R (i,a) (j,b)).value S := by |
| rw [p.firstBit.canonicalOutput_event R i j S hS] |
| simp_rw [p.firstBit_completeReference,Matrix.mul_sum,Matrix.sum_mul] |
| rw [integral_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => |
| (integrable_filter (preparationFilter R) (p.completeReference_integrable (i,a) (j,b))).integrableOn))] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [integral_finsetSum _ (fun b _ => |
| (integrable_filter (preparationFilter R) (p.completeReference_integrable (i,a) (j,b))).integrableOn)] |
| apply Finset.sum_congr rfl |
| intro b _ |
| exact (p.canonicalOutput_event R (i,a) (j,b) S hS).symm |
|
|
| lemma firstBit_outputDensity (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (ν : Measure (ℕ → M)) [SigmaFinite ν] (hμν : d.transcriptLaw ≪ ν) (i j : Bool) : |
| (p.firstBit.outputDensity R hR ν hμν).block i j =ᵐ[ν] |
| fun t => ∑ a : Λ, ∑ b : Λ, p.outputDensity R ν (i,a) (j,b) t := by |
| have hAC (a b : Bool × Λ) (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| (p.canonicalOutput R a b).value S = 0 := p.canonicalOutput_ac R a b S hS (hμν hz) |
| have hi (a b : Bool × Λ) : Integrable (p.outputDensity R ν a b) ν := |
| (p.canonicalOutput R a b).positiveDensity_integrable ν (hAC a b) |
| apply (p.firstBit.canonicalOutput R i j).positiveDensity_eq_ae ν |
| (integrable_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => hi (i,a) (j,b)))) |
| intro S hS |
| rw [p.firstBit_output_event R i j S hS] |
| rw [integral_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => (hi (i,a) (j,b)).integrableOn))] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [integral_finsetSum _ (fun b _ => (hi (i,a) (j,b)).integrableOn)] |
| apply Finset.sum_congr rfl |
| intro b _ |
| exact ((p.canonicalOutput R (i,a) (j,b)).positiveDensity_integral ν (hAC (i,a) (j,b)) S hS).symm |
|
|
| end FiniteProtocol |
|
|
| end |
|
|
| open UnrestrictedQuantum |
|
|
| universe v10829_0 v10829_1 v10829_2 v10829_3 v10829_4 v10829_5 v10829_6 v10829_7 v10829_8 v10829_9 v10829_10 |
|
|
| variable {O : Type v10829_0} {M : Type v10829_1} {ι : Type v10829_2} {η : Type v10829_3} [inst10829_0 : MeasurableSpace O] [inst10829_1 : MeasurableSpace M] |
| [inst10829_2 : StandardBorelSpace O] [inst10829_3 : Nonempty O] [inst10829_4 : StandardBorelSpace M] [inst10829_5 : Nonempty M] |
| [inst10829_6 : Fintype ι] [inst10829_7 : Fintype η] [inst10829_8 : DecidableEq ι] [inst10829_9 : DecidableEq η] [inst10829_10 : Nonempty ι] [inst10829_11 : Nonempty η] |
| {K : Type v10829_4} [inst10829_12 : MeasurableSpace K] [inst10829_13 : MeasurableSingletonClass K] |
| [inst10829_14 : Fintype K] [inst10829_15 : DecidableEq K] [inst10829_16 : Nonempty K] |
| (d : Discussion O M) |
| (A : ℕ → Type v10829_5) (B : ℕ → Type v10829_6) |
| [inst10829_17 : ∀ n, AddCommGroup (A n)] [inst10829_18 : ∀ n, Module ℂ (A n)] [inst10829_19 : ∀ n, One (A n)] [inst10829_20 : ∀ n, LE (A n)] |
| [inst10829_21 : ∀ n, AddCommGroup (B n)] [inst10829_22 : ∀ n, Module ℂ (B n)] [inst10829_23 : ∀ n, One (B n)] [inst10829_24 : ∀ n, LE (B n)] |
| (TA : Type v10829_7) (TB : Type v10829_8) (CA : Type v10829_9) (CB : Type v10829_10) |
| [inst10829_25 : AddCommGroup TA] [inst10829_26 : Module ℂ TA] [inst10829_27 : One TA] [inst10829_28 : LE TA] |
| [inst10829_29 : AddCommGroup TB] [inst10829_30 : Module ℂ TB] [inst10829_31 : One TB] [inst10829_32 : LE TB] |
| [inst10829_33 : AddCommGroup CA] [inst10829_34 : Module ℂ CA] [inst10829_35 : One CA] [inst10829_36 : LE CA] |
| [inst10829_37 : AddCommGroup CB] [inst10829_38 : Module ℂ CB] [inst10829_39 : One CB] [inst10829_40 : LE CB] |
|
|
| variable {d A B TA TB CA CB} |
|
|
| namespace FiniteProtocol |
|
|
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := K) d A B TA TB CA CB) |
|
|
| def secretKeyError (R : Matrix (ι × η) (ι × η) ℂ) |
| (sigma : PositiveMatrixMeasure (ℕ → M) (ι × η)) : ℝ := |
| let ν := d.transcriptLaw + sigma.traceMeasure |
| cqDistance (p.outputDensity R ν) |
| (fun a b t => idealFiniteBlocks (sigma.positiveDensity ν t) a b) ν |
|
|
| omit inst10829_10 inst10829_11 in |
| lemma secretKeyError_nonneg [Nonempty ι] [Nonempty η] (R : Matrix (ι × η) (ι × η) ℂ) |
| (sigma : PositiveMatrixMeasure (ℕ → M) (ι × η)) : 0 ≤ p.secretKeyError R sigma := by |
| exact Finset.sum_nonneg fun a _ => Finset.sum_nonneg fun b _ => |
| integral_nonneg fun t => traceNorm_nonneg _ |
|
|
| end FiniteProtocol |
|
|
| universe v10864_0 |
|
|
| variable {Λ : Type v10864_0} [inst10864_0 : MeasurableSpace Λ] [inst10864_1 : MeasurableSingletonClass Λ] |
| [inst10864_2 : Fintype Λ] [inst10864_3 : DecidableEq Λ] [inst10864_4 : Nonempty Λ] |
|
|
| namespace FiniteProtocol |
|
|
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := Bool × Λ) d A B TA TB CA CB) |
|
|
| theorem firstBit_error_le (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (sigma : PositiveMatrixMeasure (ℕ → M) (ι × η)) : |
| p.firstBit.secretBitError R hR sigma ≤ p.secretKeyError R sigma := by |
| let ν := d.transcriptLaw + sigma.traceMeasure |
| have hμν : d.transcriptLaw ≪ ν := Measure.AbsolutelyContinuous.rfl.add_right _ |
| have hsν : sigma.traceMeasure ≪ ν := Measure.AbsolutelyContinuous.rfl.add_right' _ |
| have hsAC (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| sigma.value S = 0 := sigma.value_zero_of_traceMeasure_zero S hS (hsν hz) |
| have hAC (a b : Bool × Λ) (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| (p.canonicalOutput R a b).value S = 0 := p.canonicalOutput_ac R a b S hS (hμν hz) |
| have h := cqFirstBit_ideal_le (p.outputDensity R ν) |
| (fun a b => (p.canonicalOutput R a b).measurable_positiveDensity ν) |
| (fun a b => (p.canonicalOutput R a b).positiveDensity_pos ν) |
| (fun a b => (p.canonicalOutput R a b).integrable_positiveDensity_trace ν (hAC a b)) |
| (sigma.positiveDensity ν) (sigma.measurable_positiveDensity ν) |
| (sigma.positiveDensity_pos ν) (sigma.integrable_positiveDensity_trace ν hsAC) |
| apply le_trans (le_of_eq ?_) h |
| change (p.firstBit.outputDensity R hR ν hμν).idealBitError (sigma.positiveDensity ν) = _ |
| rw [BitDensity.idealBitError_eq_cq] |
| unfold cqBitError |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply integral_congr_ae |
| filter_upwards [p.firstBit_outputDensity R hR ν hμν i j] with t ht |
| rw [ht] |
| rfl |
|
|
| theorem uniform_key_gap {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (p : FiniteProtocol (ι := Fin a) (η := Fin b) (K := Bool × Λ) d A B TA TB CA CB) |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : InClass R) |
| (sigma : PositiveMatrixMeasure (ℕ → M) (Fin a × Fin b)) |
| (hsigma : (trace (sigma.value Set.univ)).re = 1) : |
| 1/5 ≤ p.secretKeyError R sigma := |
| (p.firstBit.uniform_gap R hR sigma hsigma).trans (p.firstBit_error_le R hR.1 sigma) |
|
|
| end FiniteProtocol |
|
|
| end |
|
|
| section |
|
|
| open Matrix MeasureTheory ProbabilityTheory Function Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
|
|
| open UnrestrictedQuantum |
|
|
| universe v11008_0 v11008_1 v11008_2 v11008_3 v11008_4 v11008_5 v11008_6 v11008_7 v11008_8 v11008_9 v11008_10 v11008_11 |
|
|
| variable {O : Type v11008_0} {M : Type v11008_1} {ι : Type v11008_2} {η : Type v11008_3} [inst11008_0 : MeasurableSpace O] [inst11008_1 : MeasurableSpace M] |
| [inst11008_2 : StandardBorelSpace O] [inst11008_3 : Nonempty O] [inst11008_4 : StandardBorelSpace M] [inst11008_5 : Nonempty M] |
| [inst11008_6 : Fintype ι] [inst11008_7 : Fintype η] [inst11008_8 : DecidableEq ι] [inst11008_9 : DecidableEq η] [inst11008_10 : Nonempty ι] [inst11008_11 : Nonempty η] |
| {K : Type v11008_4} [inst11008_12 : MeasurableSpace K] [inst11008_13 : MeasurableSingletonClass K] |
| [inst11008_14 : Fintype K] [inst11008_15 : DecidableEq K] [inst11008_16 : Nonempty K] |
| {d : Discussion O M} {A : ℕ → Type v11008_5} {B : ℕ → Type v11008_6} |
| [inst11008_17 : ∀ n, AddCommGroup (A n)] [inst11008_18 : ∀ n, Module ℂ (A n)] [inst11008_19 : ∀ n, One (A n)] [inst11008_20 : ∀ n, LE (A n)] |
| [inst11008_21 : ∀ n, AddCommGroup (B n)] [inst11008_22 : ∀ n, Module ℂ (B n)] [inst11008_23 : ∀ n, One (B n)] [inst11008_24 : ∀ n, LE (B n)] |
| {TA : Type v11008_7} {TB : Type v11008_8} {CA : Type v11008_9} {CB : Type v11008_10} |
| [inst11008_25 : AddCommGroup TA] [inst11008_26 : Module ℂ TA] [inst11008_27 : One TA] [inst11008_28 : LE TA] |
| [inst11008_29 : AddCommGroup TB] [inst11008_30 : Module ℂ TB] [inst11008_31 : One TB] [inst11008_32 : LE TB] |
| [inst11008_33 : AddCommGroup CA] [inst11008_34 : Module ℂ CA] [inst11008_35 : One CA] [inst11008_36 : LE CA] |
| [inst11008_37 : AddCommGroup CB] [inst11008_38 : Module ℂ CB] [inst11008_39 : One CB] [inst11008_40 : LE CB] |
| {κ : Type v11008_11} [inst11008_41 : Fintype κ] [inst11008_42 : DecidableEq κ] |
|
|
| namespace FiniteProtocol |
|
|
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := K) d A B TA TB CA CB) |
|
|
| def purifiedSecretKeyError (P : Matrix (ι × η) κ ℂ) |
| (sigma : PositiveMatrixMeasure (ℕ → M) κ) : ℝ := |
| let ν := d.transcriptLaw + sigma.traceMeasure |
| cqDistance (p.purifiedOutputDensity P ν) |
| (fun a b t => idealFiniteBlocks (sigma.positiveDensity ν t) a b) ν |
|
|
| end FiniteProtocol |
|
|
| universe v11066_0 |
|
|
| variable {Λ : Type v11066_0} [inst11066_0 : MeasurableSpace Λ] [inst11066_1 : MeasurableSingletonClass Λ] |
| [inst11066_2 : Fintype Λ] [inst11066_3 : DecidableEq Λ] [inst11066_4 : Nonempty Λ] |
|
|
| namespace FiniteProtocol |
|
|
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := Bool × Λ) d A B TA TB CA CB) |
|
|
| lemma firstBit_purifiedOutput_event (P : Matrix (ι × η) κ ℂ) |
| (i j : Bool) (S : Set (ℕ → M)) (hS : MeasurableSet S) : |
| (p.firstBit.purifiedOutput P i j).value S = |
| ∑ a : Λ, ∑ b : Λ, (p.purifiedOutput P (i,a) (j,b)).value S := by |
| rw [BitProtocol.purifiedOutput,PositiveMatrixMeasure.filter_value, |
| p.firstBit.probeOutput_event i j S hS, |
| ← integral_filter _ (p.firstBit.completeReference_integrable i j).integrableOn] |
| simp_rw [p.firstBit_completeReference,Matrix.mul_sum,Matrix.sum_mul] |
| rw [integral_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => |
| (integrable_filter (purificationFilter P) (p.completeReference_integrable (i,a) (j,b))).integrableOn))] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [integral_finsetSum _ (fun b _ => |
| (integrable_filter (purificationFilter P) (p.completeReference_integrable (i,a) (j,b))).integrableOn)] |
| apply Finset.sum_congr rfl |
| intro b _ |
| exact (p.purifiedOutput_event P (i,a) (j,b) S hS).symm |
|
|
| lemma firstBit_purifiedOutputDensity (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (P : Matrix (ι × η) κ ℂ) (hP : P * Pᴴ = R) |
| (ν : Measure (ℕ → M)) [SigmaFinite ν] (hμν : d.transcriptLaw ≪ ν) (i j : Bool) : |
| (p.firstBit.purifiedDensity R hR P hP ν hμν).block i j =ᵐ[ν] |
| fun t => ∑ a : Λ, ∑ b : Λ, p.purifiedOutputDensity P ν (i,a) (j,b) t := by |
| have hAC (a b : Bool × Λ) (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| (p.purifiedOutput P a b).value S = 0 := p.purifiedOutput_ac P a b S hS (hμν hz) |
| have hi (a b : Bool × Λ) : Integrable (p.purifiedOutputDensity P ν a b) ν := |
| (p.purifiedOutput P a b).positiveDensity_integrable ν (hAC a b) |
| apply (p.firstBit.purifiedOutput P i j).positiveDensity_eq_ae ν |
| (integrable_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => hi (i,a) (j,b)))) |
| intro S hS |
| rw [p.firstBit_purifiedOutput_event P i j S hS] |
| rw [integral_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => (hi (i,a) (j,b)).integrableOn))] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [integral_finsetSum _ (fun b _ => (hi (i,a) (j,b)).integrableOn)] |
| apply Finset.sum_congr rfl |
| intro b _ |
| exact ((p.purifiedOutput P (i,a) (j,b)).positiveDensity_integral ν (hAC (i,a) (j,b)) S hS).symm |
|
|
| theorem firstBit_purified_error_le (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (P : Matrix (ι × η) κ ℂ) (hP : P * Pᴴ = R) |
| (sigma : PositiveMatrixMeasure (ℕ → M) κ) : |
| p.firstBit.purifiedSecretBitError R hR P hP sigma ≤ p.purifiedSecretKeyError P sigma := by |
| let ν := d.transcriptLaw + sigma.traceMeasure |
| have hμν : d.transcriptLaw ≪ ν := Measure.AbsolutelyContinuous.rfl.add_right _ |
| have hsν : sigma.traceMeasure ≪ ν := Measure.AbsolutelyContinuous.rfl.add_right' _ |
| have hsAC (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| sigma.value S = 0 := sigma.value_zero_of_traceMeasure_zero S hS (hsν hz) |
| have hAC (a b : Bool × Λ) (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : ν S = 0) : |
| (p.purifiedOutput P a b).value S = 0 := p.purifiedOutput_ac P a b S hS (hμν hz) |
| have h := cqFirstBit_ideal_le (p.purifiedOutputDensity P ν) |
| (fun a b => (p.purifiedOutput P a b).measurable_positiveDensity ν) |
| (fun a b => (p.purifiedOutput P a b).positiveDensity_pos ν) |
| (fun a b => (p.purifiedOutput P a b).integrable_positiveDensity_trace ν (hAC a b)) |
| (sigma.positiveDensity ν) (sigma.measurable_positiveDensity ν) |
| (sigma.positiveDensity_pos ν) (sigma.integrable_positiveDensity_trace ν hsAC) |
| apply le_trans (le_of_eq ?_) h |
| change (p.firstBit.purifiedDensity R hR P hP ν hμν).idealBitError (sigma.positiveDensity ν) = _ |
| rw [BitDensity.idealBitError_eq_cq] |
| unfold cqBitError |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply integral_congr_ae |
| filter_upwards [p.firstBit_purifiedOutputDensity R hR P hP ν hμν i j] with t ht |
| rw [ht] |
| rfl |
|
|
| theorem uniform_purified_key_gap {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (p : FiniteProtocol (ι := Fin a) (η := Fin b) (K := Bool × Λ) d A B TA TB CA CB) |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : InClass R) |
| (P : Matrix (Fin a × Fin b) κ ℂ) (hP : P * Pᴴ = R) |
| (sigma : PositiveMatrixMeasure (ℕ → M) κ) |
| (hsigma : (trace (sigma.value Set.univ)).re = 1) : |
| 1/5 ≤ p.purifiedSecretKeyError P sigma := |
| (p.firstBit.uniform_gap_purification R hR P hP sigma hsigma).trans |
| (p.firstBit_purified_error_le R hR.1 P hP sigma) |
|
|
| end FiniteProtocol |
|
|
| end |
|
|
| open Matrix MeasureTheory Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
|
|
| universe v11165_0 v11165_1 v11165_2 |
|
|
| variable {Ω : Type v11165_0} {ι : Type v11165_1} {K : Type v11165_2} [inst11165_0 : MeasurableSpace Ω] [inst11165_1 : Fintype ι] [inst11165_2 : DecidableEq ι] |
| [inst11165_3 : Fintype K] [inst11165_4 : DecidableEq K] {μ : Measure Ω} |
|
|
| namespace KeyDensity |
|
|
| variable (τ υ : KeyDensity μ K ι) (sigma : EveDensity μ ι) |
|
|
| lemma idealError_nonneg : 0 ≤ τ.idealError sigma := cqDistance_nonneg _ _ |
|
|
| lemma distance_nonneg : 0 ≤ τ.distance υ := cqDistance_nonneg _ _ |
|
|
| omit inst11165_4 in |
| lemma distance_self [DecidableEq K] : τ.distance τ = 0 := by |
| have hz : traceNorm (0 : Matrix ι ι ℂ) = 0 := by |
| rw [traceNorm_posSemidef (Matrix.PosSemidef.zero)]; simp |
| simp [distance,cqDistance,hz] |
|
|
| lemma idealError_triangle : τ.idealError sigma ≤ τ.distance υ + υ.idealError sigma := |
| cqDistance_triangle τ.block υ.block (fun a b t => idealFiniteBlocks (sigma.block t) a b) |
| τ.measurable υ.measurable (idealFinite_measurable sigma.block sigma.measurable) |
| τ.positive υ.positive (fun a b t => idealFinite_positive (sigma.block t) (sigma.positive t) a b) |
| τ.integrable υ.integrable (idealFinite_trace_integrable sigma.block sigma.integrable) |
|
|
| theorem gap_of_traceNorm_limit (τ : ℕ → KeyDensity μ K ι) (υ : KeyDensity μ K ι) |
| (sigma : EveDensity μ ι) (hgap : ∀ n, 1/5 ≤ (τ n).idealError sigma) |
| (hlim : Tendsto (fun n => (τ n).distance υ) atTop (nhds 0)) : |
| 1/5 ≤ υ.idealError sigma := by |
| have hle (n : ℕ) := (hgap n).trans ((τ n).idealError_triangle υ sigma) |
| have ht : Tendsto (fun n => (τ n).distance υ + υ.idealError sigma) |
| atTop (nhds (υ.idealError sigma)) := by simpa using hlim.add_const (υ.idealError sigma) |
| exact ge_of_tendsto ht (Filter.Eventually.of_forall hle) |
|
|
| end KeyDensity |
|
|
| namespace PositiveMatrixMeasure |
|
|
| def toEveDensity (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) [SigmaFinite μ] |
| (hAC : ∀ S, MeasurableSet S → μ S = 0 → W.value S = 0) |
| (hn : (trace (W.value Set.univ)).re = 1) : EveDensity μ ι where |
| block := W.positiveDensity μ |
| measurable := W.measurable_positiveDensity μ |
| positive := W.positiveDensity_pos μ |
| integrable := W.integrable_positiveDensity_trace μ hAC |
| normalized := (W.integral_positiveDensity_trace μ hAC).trans hn |
|
|
| end PositiveMatrixMeasure |
|
|
| end ZeroKey |
|
|
| open Matrix MeasureTheory ProbabilityTheory Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
|
|
| namespace ZeroKey |
|
|
| open UnrestrictedQuantum |
|
|
| universe v11244_0 v11244_1 v11244_2 v11244_3 v11244_4 v11244_5 v11244_6 v11244_7 v11244_8 v11244_9 v11244_10 v11244_11 |
|
|
| variable {O : Type v11244_0} {M : Type v11244_1} {ι : Type v11244_2} {η : Type v11244_3} [inst11244_0 : MeasurableSpace O] [inst11244_1 : MeasurableSpace M] |
| [inst11244_2 : StandardBorelSpace O] [inst11244_3 : Nonempty O] [inst11244_4 : StandardBorelSpace M] [inst11244_5 : Nonempty M] |
| [inst11244_6 : Fintype ι] [inst11244_7 : Fintype η] [inst11244_8 : DecidableEq ι] [inst11244_9 : DecidableEq η] [inst11244_10 : Nonempty ι] [inst11244_11 : Nonempty η] |
| {K : Type v11244_4} [inst11244_12 : MeasurableSpace K] [inst11244_13 : MeasurableSingletonClass K] |
| [inst11244_14 : Fintype K] [inst11244_15 : DecidableEq K] [inst11244_16 : Nonempty K] |
| {d : Discussion O M} {A : ℕ → Type v11244_5} {B : ℕ → Type v11244_6} |
| [inst11244_17 : ∀ n, AddCommGroup (A n)] [inst11244_18 : ∀ n, Module ℂ (A n)] [inst11244_19 : ∀ n, One (A n)] [inst11244_20 : ∀ n, LE (A n)] |
| [inst11244_21 : ∀ n, AddCommGroup (B n)] [inst11244_22 : ∀ n, Module ℂ (B n)] [inst11244_23 : ∀ n, One (B n)] [inst11244_24 : ∀ n, LE (B n)] |
| {TA : Type v11244_7} {TB : Type v11244_8} {CA : Type v11244_9} {CB : Type v11244_10} |
| [inst11244_25 : AddCommGroup TA] [inst11244_26 : Module ℂ TA] [inst11244_27 : One TA] [inst11244_28 : LE TA] |
| [inst11244_29 : AddCommGroup TB] [inst11244_30 : Module ℂ TB] [inst11244_31 : One TB] [inst11244_32 : LE TB] |
| [inst11244_33 : AddCommGroup CA] [inst11244_34 : Module ℂ CA] [inst11244_35 : One CA] [inst11244_36 : LE CA] |
| [inst11244_37 : AddCommGroup CB] [inst11244_38 : Module ℂ CB] [inst11244_39 : One CB] [inst11244_40 : LE CB] |
| {κ : Type v11244_11} [inst11244_41 : Fintype κ] [inst11244_42 : DecidableEq κ] |
|
|
| theorem BitProtocol.uniform_gap_purification_dominated |
| {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (p : BitProtocol (ι := Fin a) (η := Fin b) d A B TA TB CA CB) |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : InClass R) |
| (P : Matrix (Fin a × Fin b) κ ℂ) (hP : P * Pᴴ = R) |
| (ν : Measure (ℕ → M)) [SigmaFinite ν] (hμν : d.transcriptLaw ≪ ν) |
| (sigma : EveDensity ν κ) : |
| 1/5 ≤ (p.purifiedDensity R hR.1 P hP ν hμν).idealBitError sigma.block := by |
| obtain ⟨L,hpos,htr,hrec⟩ := p.purifiedOutput_recovery R hR.1 P hP |
| let tp := p.purifiedDensity R hR.1 P hP ν hμν |
| let tc := p.outputDensity R hR.1 ν hμν |
| have hg := p.uniform_gap_dominated R hR ν hμν |
| (fun t => L (sigma.block t)) (L.continuous_of_finiteDimensional.measurable.comp sigma.measurable) |
| (fun t => hpos _ (sigma.positive t)) |
| (show Integrable (fun t => (trace (L (sigma.block t))).re) ν by simpa only [htr] using sigma.integrable) |
| (show (∫ t, (trace (L (sigma.block t))).re ∂ν) = 1 by simpa only [htr] using sigma.normalized) |
| have hrc := BitDensity.idealBitError_congr tc (tp.mapReference L hpos htr) |
| (fun t => L (sigma.block t)) (fun t => L (sigma.block t)) |
| (p.purifiedDensity_recovery R hR.1 P hP ν hμν L hrec) Filter.EventuallyEq.rfl |
| have hc := tp.idealBitError_mapReference_le L hpos htr sigma.block |
| sigma.measurable sigma.positive sigma.integrable |
| change 1/5 ≤ tp.idealBitError sigma.block |
| rw [hrc] at hg |
| exact hg.trans hc |
|
|
| universe v11305_0 |
|
|
| variable {Λ : Type v11305_0} [inst11305_0 : MeasurableSpace Λ] [inst11305_1 : MeasurableSingletonClass Λ] |
| [inst11305_2 : Fintype Λ] [inst11305_3 : DecidableEq Λ] [inst11305_4 : Nonempty Λ] |
|
|
| theorem FiniteProtocol.uniform_purified_key_gap_dominated |
| {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (p : FiniteProtocol (ι := Fin a) (η := Fin b) (K := Bool × Λ) d A B TA TB CA CB) |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : InClass R) |
| (P : Matrix (Fin a × Fin b) κ ℂ) (hP : P * Pᴴ = R) |
| (ν : Measure (ℕ → M)) [SigmaFinite ν] (hμν : d.transcriptLaw ≪ ν) |
| (sigma : EveDensity ν κ) : |
| 1/5 ≤ (p.purifiedKeyDensity R hR.1 P hP ν hμν).idealError sigma := by |
| let τ := p.purifiedKeyDensity R hR.1 P hP ν hμν |
| have hc := cqFirstBit_ideal_le τ.block τ.measurable τ.positive τ.integrable |
| sigma.block sigma.measurable sigma.positive sigma.integrable |
| have he : (p.firstBit.purifiedDensity R hR.1 P hP ν hμν).idealBitError sigma.block = |
| cqBitError (fun i j t => firstBitBlocks (fun a b => τ.block a b t) i j) sigma.block ν := by |
| rw [BitDensity.idealBitError_eq_cq] |
| unfold cqBitError |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply integral_congr_ae |
| filter_upwards [p.firstBit_purifiedOutputDensity R hR.1 P hP ν hμν i j] with t ht |
| rw [ht] |
| rfl |
| have hg := p.firstBit.uniform_gap_purification_dominated R hR P hP ν hμν sigma |
| rw [he] at hg |
| exact hg.trans hc |
|
|
| end ZeroKey |
|
|
| end |
|
|
| end OAI |
|
|
