| import OAI.InformationTheory.SecretKey.Purification |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace ZeroKey |
|
|
| section |
|
|
| open Matrix MeasureTheory ProbabilityTheory Filter |
|
|
| universe u |
|
|
| lemma card_keyWord (n : ℕ) : Fintype.card (KeyWord n) = 2^n := by |
| induction n with |
| | zero => change Fintype.card Unit = 1; exact Fintype.card_unique |
| | succ n ih => |
| change Fintype.card (Bool × KeyWord n) = _ |
| rw [Fintype.card_prod,Fintype.card_bool,ih,pow_succ,mul_comm] |
|
|
| end |
|
|
| section |
|
|
| open MeasureTheory Filter |
|
|
| open scoped ENNReal |
|
|
| universe v11415_0 |
|
|
| variable {Ω : Type v11415_0} [inst11415_0 : MeasurableSpace Ω] |
|
|
| def commonPublicLaw (μ : ℕ → Measure Ω) : Measure Ω := |
| Measure.sum (fun n => (2⁻¹ : ℝ≥0∞)^n • μ n) |
|
|
| lemma commonPublicLaw_univ (μ : ℕ → Measure Ω) [∀ n, IsProbabilityMeasure (μ n)] : |
| commonPublicLaw μ Set.univ = 2 := by |
| simp only [commonPublicLaw,Measure.sum_apply _ MeasurableSet.univ,Measure.smul_apply, |
| measure_univ,smul_eq_mul,mul_one] |
| exact ENNReal.tsum_geometric_two |
| |
| instance commonPublicLaw_finite (μ : ℕ → Measure Ω) [∀ n, IsProbabilityMeasure (μ n)] : |
| IsFiniteMeasure (commonPublicLaw μ) := ⟨by rw [commonPublicLaw_univ]; norm_num⟩ |
| |
| lemma absolutelyContinuous_commonPublicLaw (μ : ℕ → Measure Ω) (n : ℕ) : |
| μ n ≪ commonPublicLaw μ := by |
| apply Measure.absolutelyContinuous_sum_right n |
| apply Measure.AbsolutelyContinuous.mk |
| intro S hS hzero |
| have hp : (2⁻¹ : ℝ≥0∞)^n ≠ 0 := pow_ne_zero _ (by norm_num) |
| simpa only [Measure.smul_apply,smul_eq_mul,mul_eq_zero,hp,false_or] using hzero |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| universe u |
| |
| namespace KeyImplementation |
| |
| variable {a b ell : ℕ} {messages : ClassicalRecordSpace.{u}} |
| [inst11471_0 : Nonempty (Fin a)] [inst11471_1 : Nonempty (Fin b)] |
| (p : KeyImplementation a b ell messages) |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : Density R) |
| {e : ℕ} (P : Matrix (Fin a × Fin b) (Fin e) ℂ) (hP : P * Pᴴ = R) |
| (ν : Measure (ℕ → messages)) [inst11471_2 : SigmaFinite ν] (hμν : p.discussion.transcriptLaw ≪ ν) |
| |
| lemma uniform_gap (hc : InClass R) (hell : 0 < ell) (sigma : EveDensity ν (Fin e)) : |
| 1/5 ≤ (p.output R hR P hP ν hμν).idealError sigma := by |
| cases ell with |
| | zero => omega |
| | succ n => exact p.protocol.uniform_purified_key_gap_dominated R hc P hP ν hμν sigma |
| |
| end KeyImplementation |
| |
| namespace IsCompletedKeyOutput |
| |
| variable {a b ell e : ℕ} [inst11506_0 : Nonempty (Fin a)] [inst11506_1 : Nonempty (Fin b)] |
| {R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ} {hR : Density R} |
| {P : Matrix (Fin a × Fin b) (Fin e) ℂ} {hP : P * Pᴴ = R} |
| {messages : ClassicalRecordSpace.{u}} {ν : Measure (ℕ → messages)} [inst11506_2 : SigmaFinite ν] |
| {τ : KeyDensity ν (KeyWord ell) (Fin e)} |
| |
| lemma of_implementation (p : KeyImplementation a b ell messages) |
| (hAC : p.discussion.transcriptLaw ≪ ν) : |
| IsCompletedKeyOutput R hR P hP messages ν (p.output R hR P hP ν hAC) := by |
| apply (isCompletedKeyOutput_iff_original R hR P hP messages ν _).2 |
| refine ⟨fun _ => p,fun _ => hAC,?_⟩ |
| simpa only [KeyDensity.distance_self] using |
| (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0 : ℝ)) atTop (nhds 0)) |
| |
| theorem uniform_gap (hτ : IsCompletedKeyOutput R hR P hP messages ν τ) |
| (hc : InClass R) (hell : 0 < ell) (sigma : EveDensity ν (Fin e)) : |
| 1/5 ≤ τ.idealError sigma := by |
| obtain ⟨p,hAC,hlim⟩ := hτ |
| exact KeyDensity.gap_of_traceNorm_limit |
| (fun j => (p j).output R hR P hP ν (hAC j)) τ sigma |
| (fun j => (p j).uniform_gap R hR P hP ν (hAC j) hc hell sigma) hlim |
| |
| end IsCompletedKeyOutput |
| |
| attribute [instance] CompletedKeyTrial.sigmaFinite |
| |
| namespace CompletedKeyTrial |
| |
| variable {a b ell : ℕ} [inst11550_0 : Nonempty (Fin a)] [inst11550_1 : Nonempty (Fin b)] |
| {R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ} {hR : Density R} |
| (p : CompletedKeyTrial R hR ell) |
| |
| lemma error_nonneg : 0 ≤ p.error := p.actual.idealError_nonneg p.ideal |
| |
| lemma uniform_error (hc : InClass R) (hell : 0 < ell) : 1/5 ≤ p.error := |
| p.completed.uniform_gap hc hell p.ideal |
| |
| end CompletedKeyTrial |
| |
| end |
| |
| open scoped ComplexOrder MatrixOrder Kronecker |
| |
| open Matrix |
| |
| def groupVector {a b c d : ℕ} (u : Fin a × Fin b → ℂ) (v : Fin c × Fin d → ℂ) : |
| Fin (a*c) × Fin (b*d) → ℂ := fun i => |
| u (groupIndex a b c d i).1 * v (groupIndex a b c d i).2 |
| |
| lemma outer_groupVector {a b c d : ℕ} (u : Fin a × Fin b → ℂ) (v : Fin c × Fin d → ℂ) : |
| outer (groupVector u v) (groupVector u v) = groupTensor (outer u u) (outer v v) := by |
| ext i j |
| simp only [outer,groupVector,groupTensor,Matrix.submatrix_apply,Matrix.kroneckerMap_apply,star_mul] |
| ring |
| |
| lemma tensorMap_kronecker {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) |
| (A : Mat a) (B : Mat c) : tensorMap L M (A ⊗ₖ B) = L A ⊗ₖ M B := by |
| ext ⟨i,k⟩ ⟨j,l⟩ |
| simp only [tensorMap,Matrix.kronecker_apply] |
| have hL := linearMap_matrix_units_apply L A i j |
| have hM := linearMap_matrix_units_apply M B k l |
| rw [hL,hM] |
| simp only [Finset.sum_mul] |
| simp only [Finset.mul_sum] |
| apply Finset.sum_congr rfl; intro x _ |
| apply Finset.sum_congr rfl; intro y _ |
| apply Finset.sum_congr rfl; intro z _ |
| apply Finset.sum_congr rfl; intro w _ |
| ring |
| |
| lemma matrixUnit_finProd {a c : ℕ} (x y : Fin (a*c)) : |
| (matrixUnit x y).submatrix finProdFinEquiv finProdFinEquiv = |
| matrixUnit (finProdFinEquiv.symm x).1 (finProdFinEquiv.symm y).1 ⊗ₖ |
| matrixUnit (finProdFinEquiv.symm x).2 (finProdFinEquiv.symm y).2 := by |
| ext ⟨i,k⟩ ⟨j,l⟩ |
| simp only [Matrix.submatrix_apply, matrixUnit, Matrix.kronecker_apply] |
| have hx : finProdFinEquiv (i,k) = x ↔ i = (finProdFinEquiv.symm x).1 ∧ |
| k = (finProdFinEquiv.symm x).2 := by |
| rw [← Equiv.eq_symm_apply] |
| exact Prod.ext_iff |
| have hy : finProdFinEquiv (j,l) = y ↔ j = (finProdFinEquiv.symm y).1 ∧ |
| l = (finProdFinEquiv.symm y).2 := by |
| rw [← Equiv.eq_symm_apply] |
| exact Prod.ext_iff |
| simp only [hx,hy] |
| split_ifs <;> simp_all |
| |
| lemma tensorLinear_unit {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) |
| (x y : Fin (a*c)) (i j : Fin (b*d)) : |
| tensorLinear L M (matrixUnit x y) i j = |
| L (matrixUnit (finProdFinEquiv.symm x).1 (finProdFinEquiv.symm y).1) |
| (finProdFinEquiv.symm i).1 (finProdFinEquiv.symm j).1 * |
| M (matrixUnit (finProdFinEquiv.symm x).2 (finProdFinEquiv.symm y).2) |
| (finProdFinEquiv.symm i).2 (finProdFinEquiv.symm j).2 := by |
| change (tensorMap L M _ _ _) = _ |
| rw [matrixUnit_finProd,tensorMap_kronecker] |
| rfl |
| |
| lemma tensorMap_groupTensor {a b c d e f g h : ℕ} |
| (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) |
| (N : Mat e →ₗ[ℂ] Mat f) (P : Mat g →ₗ[ℂ] Mat h) |
| (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) |
| (V : Matrix (Fin e × Fin g) (Fin e × Fin g) ℂ) : |
| tensorMap (tensorLinear L N) (tensorLinear M P) (groupTensor U V) = |
| groupTensor (tensorMap L M U) (tensorMap N P V) := by |
| ext ⟨i,k⟩ ⟨j,l⟩ |
| simp only [tensorMap, tensorLinear_unit,groupTensor,Matrix.submatrix_apply, |
| Matrix.kronecker_apply,groupIndex,Equiv.coe_fn_mk] |
| simp_rw [← Equiv.sum_comp (finProdFinEquiv : Fin a × Fin e ≃ _)] |
| simp_rw [← Equiv.sum_comp (finProdFinEquiv : Fin c × Fin g ≃ _)] |
| simp only [Equiv.symm_apply_apply,Fintype.sum_prod_type] |
| simp only [Finset.sum_mul] |
| simp only [Finset.mul_sum] |
| apply Finset.sum_congr rfl; intro x _ |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl; intro y _ |
| conv_lhs => arg 2; ext xv; rw [Finset.sum_comm] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl; intro z _ |
| conv_lhs => arg 2; ext xv; arg 2; ext yv; rw [Finset.sum_comm] |
| conv_lhs => arg 2; ext xv; rw [Finset.sum_comm] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl; intro w _ |
| apply Finset.sum_congr rfl; intro xv _ |
| apply Finset.sum_congr rfl; intro yv _ |
| apply Finset.sum_congr rfl; intro zv _ |
| apply Finset.sum_congr rfl; intro wv _ |
| ring |
| |
| lemma InClass.groupTensor {a b c d : ℕ} |
| {R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ} |
| {S : Matrix (Fin c × Fin d) (Fin c × Fin d) ℂ} |
| (hR : InClass R) (hS : InClass S) : InClass (groupTensor R S) := by |
| obtain ⟨hdR,p,q,L,M,u,hL,hM,hu⟩ := hR |
| obtain ⟨hdS,r,s,N,P,v,hN,hP,hv⟩ := hS |
| refine ⟨hdR.groupTensor hdS,p*r,q*s,tensorLinear L N,tensorLinear M P, |
| groupVector u v,ppt_tensorLinear hL hN,ppt_tensorLinear hM hP,?_⟩ |
| rw [outer_groupVector,tensorMap_groupTensor,← hu,← hv] |
| |
| lemma InClass.positiveCopies {a b : ℕ} |
| {R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ} (hR : InClass R) (k : ℕ) : |
| InClass (positiveCopies R k) := by |
| induction k with |
| | zero => exact hR |
| | succ k ih => exact ih.groupTensor hR |
| |
| end ZeroKey |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator ENNReal |
| |
| namespace ZeroKey |
| |
| universe u |
| |
| namespace CompletedKeyScheme |
| |
| variable {a b : ℕ} [inst11756_0 : Nonempty (Fin a)] [inst11756_1 : Nonempty (Fin b)] |
| {R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ} {hR : Density R} |
| (s : CompletedKeyScheme.{u} R hR) |
| |
| lemma eventually_length_zero (hc : InClass R) (hs : s.Secure) : |
| ∀ᶠ k in atTop, s.length k = 0 := by |
| have he : ∀ᶠ k in atTop, s.error k < 1/5 := (tendsto_order.mp hs).2 _ (by norm_num) |
| filter_upwards [he] with k hk |
| by_contra hn |
| exact (not_lt_of_ge ((s.trial k).uniform_error (hc.positiveCopies k) |
| (Nat.pos_of_ne_zero hn))) hk |
| |
| lemma lowerRate_zero (hc : InClass R) (hs : s.Secure) : s.lowerRate = 0 := by |
| unfold lowerRate |
| have he : (fun k : ℕ => (s.length k : ℝ≥0∞) / (k+1 : ℕ)) =ᶠ[atTop] fun _ => 0 := by |
| filter_upwards [s.eventually_length_zero hc hs] with k hk |
| simp [hk] |
| rw [Filter.liminf_congr he] |
| simp |
| |
| end CompletedKeyScheme |
| |
| theorem class_distillableSecretKey_zero {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : Density R) (hc : InClass R) : |
| distillableSecretKey.{u} R hR = 0 := by |
| apply le_antisymm ?_ bot_le |
| apply sSup_le |
| intro r hr |
| rcases hr with rfl | ⟨s,hs,rfl⟩ |
| · rfl |
| · exact le_of_eq (s.lowerRate_zero hc hs) |
| |
| end ZeroKey |
| |
| end |
| |
| end OAI |
| |
